-/* NetHack 3.6 cmd.c $NHDT-Date: 1446975462 2015/11/08 09:37:42 $ $NHDT-Branch: master $:$NHDT-Revision: 1.206 $ */
+/* NetHack 3.6 cmd.c $NHDT-Date: 1575245052 2019/12/02 00:04:12 $ $NHDT-Branch: NetHack-3.6 $:$NHDT-Revision: 1.350 $ */
/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
+/*-Copyright (c) Robert Patrick Rankin, 2013. */
/* NetHack may be freely redistributed. See license for details. */
/* JNetHack Copyright */
/* (c) Issei Numata, Naoki Hamada, Shigehiro Miyashita, 1994-2000 */
-/* For 3.4-, Copyright (c) SHIRAKATA Kentaro, 2002-2016 */
+/* For 3.4-, Copyright (c) SHIRAKATA Kentaro, 2002-2022 */
/* JNetHack may be freely redistributed. See license for details. */
#include "hack.h"
+#include "lev.h"
#include "func_tab.h"
+/* Macros for meta and ctrl modifiers:
+ * M and C return the meta/ctrl code for the given character;
+ * e.g., (C('c') is ctrl-c
+ */
+#ifndef M
+#ifndef NHSTDC
+#define M(c) (0x80 | (c))
+#else
+#define M(c) ((c) - 128)
+#endif /* NHSTDC */
+#endif
+
+#ifndef C
+#define C(c) (0x1f & (c))
+#endif
+
+#define unctrl(c) ((c) <= C('z') ? (0x60 | (c)) : (c))
+#define unmeta(c) (0x7f & (c))
+
#ifdef ALTMETA
STATIC_VAR boolean alt_esc = FALSE;
#endif
#ifdef DEBUG
extern int NDECL(wiz_debug_cmd_bury);
-extern int NDECL(wiz_debug_cmd_traveldisplay);
#endif
#ifdef DUMB /* stuff commented out in extern.h, but needed here */
extern int NDECL(dotalk); /**/
extern int NDECL(docast); /**/
extern int NDECL(dovspell); /**/
-extern int NDECL(dotele); /**/
+extern int NDECL(dotelecmd); /**/
extern int NDECL(dountrap); /**/
extern int NDECL(doversion); /**/
extern int NDECL(doextversion); /**/
extern int NDECL(dowieldquiver); /**/
extern int NDECL(dozap); /**/
extern int NDECL(doorganize); /**/
-#endif /* DUMB */
-
-static int NDECL(dosuspend_core); /**/
+#endif /* DUMB */
static int NDECL((*timed_occ_fn));
+STATIC_PTR int NDECL(dosuspend_core);
+STATIC_PTR int NDECL(dosh_core);
+STATIC_PTR int NDECL(doherecmdmenu);
+STATIC_PTR int NDECL(dotherecmdmenu);
STATIC_PTR int NDECL(doprev_message);
STATIC_PTR int NDECL(timed_occupation);
STATIC_PTR int NDECL(doextcmd);
-STATIC_PTR int NDECL(domonability);
-STATIC_PTR int NDECL(dooverview_or_wiz_where);
STATIC_PTR int NDECL(dotravel);
STATIC_PTR int NDECL(doterrain);
STATIC_PTR int NDECL(wiz_wish);
STATIC_PTR int NDECL(wiz_identify);
+STATIC_PTR int NDECL(wiz_intrinsic);
STATIC_PTR int NDECL(wiz_map);
+STATIC_PTR int NDECL(wiz_makemap);
STATIC_PTR int NDECL(wiz_genesis);
STATIC_PTR int NDECL(wiz_where);
STATIC_PTR int NDECL(wiz_detect);
STATIC_PTR int NDECL(wiz_show_seenv);
STATIC_PTR int NDECL(wiz_show_vision);
STATIC_PTR int NDECL(wiz_smell);
-STATIC_PTR int NDECL(wiz_mon_polycontrol);
STATIC_PTR int NDECL(wiz_show_wmodes);
STATIC_DCL void NDECL(wiz_map_levltyp);
STATIC_DCL void NDECL(wiz_levltyp_legend);
#ifdef DEBUG_MIGRATING_MONS
STATIC_PTR int NDECL(wiz_migrate_mons);
#endif
-STATIC_DCL int FDECL(size_monst, (struct monst *));
+STATIC_DCL int FDECL(size_monst, (struct monst *, BOOLEAN_P));
STATIC_DCL int FDECL(size_obj, (struct obj *));
STATIC_DCL void FDECL(count_obj, (struct obj *, long *, long *,
BOOLEAN_P, BOOLEAN_P));
STATIC_DCL void FDECL(obj_chain, (winid, const char *, struct obj *,
- long *, long *));
+ BOOLEAN_P, long *, long *));
STATIC_DCL void FDECL(mon_invent_chain, (winid, const char *, struct monst *,
long *, long *));
STATIC_DCL void FDECL(mon_chain, (winid, const char *, struct monst *,
- long *, long *));
-STATIC_DCL void FDECL(contained, (winid, const char *, long *, long *));
+ BOOLEAN_P, long *, long *));
+STATIC_DCL void FDECL(contained_stats, (winid, const char *, long *, long *));
+STATIC_DCL void FDECL(misc_stats, (winid, long *, long *));
STATIC_PTR int NDECL(wiz_show_stats);
STATIC_DCL boolean FDECL(accept_menu_prefix, (int NDECL((*))));
-#ifdef PORT_DEBUG
-STATIC_DCL int NDECL(wiz_port_debug);
-#endif
STATIC_PTR int NDECL(wiz_rumor_check);
-STATIC_DCL char FDECL(cmd_from_func, (int NDECL((*))));
STATIC_PTR int NDECL(doattributes);
-STATIC_PTR int NDECL(doconduct); /**/
+STATIC_DCL void FDECL(enlght_out, (const char *));
STATIC_DCL void FDECL(enlght_line, (const char *, const char *, const char *,
const char *));
STATIC_DCL char *FDECL(enlght_combatinc, (const char *, int, int, char *));
STATIC_DCL boolean FDECL(cause_known, (int));
STATIC_DCL char *FDECL(attrval, (int, int, char *));
STATIC_DCL void FDECL(background_enlightenment, (int, int));
+STATIC_DCL void FDECL(basics_enlightenment, (int, int));
STATIC_DCL void FDECL(characteristics_enlightenment, (int, int));
STATIC_DCL void FDECL(one_characteristic, (int, int, int));
STATIC_DCL void FDECL(status_enlightenment, (int, int));
STATIC_DCL void FDECL(attributes_enlightenment, (int, int));
+STATIC_DCL void FDECL(add_herecmd_menuitem, (winid, int NDECL((*)),
+ const char *));
+STATIC_DCL char FDECL(here_cmd_menu, (BOOLEAN_P));
+STATIC_DCL char FDECL(there_cmd_menu, (BOOLEAN_P, int, int));
+STATIC_DCL char *NDECL(parse);
+STATIC_DCL void FDECL(show_direction_keys, (winid, CHAR_P, BOOLEAN_P));
+STATIC_DCL boolean FDECL(help_dir, (CHAR_P, int, const char *));
+
static const char *readchar_queue = "";
static coord clicklook_cc;
-
-STATIC_DCL char *NDECL(parse);
-STATIC_DCL boolean FDECL(help_dir, (CHAR_P, const char *));
+/* for rejecting attempts to use wizard mode commands */
+/*JP
+static const char unavailcmd[] = "Unavailable command '%s'.";
+*/
+static const char unavailcmd[] = "'%s'\83R\83}\83\93\83h\82Í\8eg\82¦\82È\82¢\81D";
+/* for rejecting #if !SHELL, !SUSPEND */
+/*JP
+static const char cmdnotavail[] = "'%s' command not available.";
+*/
+static const char cmdnotavail[] = "'%s'\83R\83}\83\93\83h\82Í\97\98\97p\82Å\82«\82Ü\82¹\82ñ\81D";
STATIC_PTR int
doprev_message(VOID_ARGS)
{
register int ch;
+ if (iflags.debug_fuzzer)
+ return randomkey();
if (!(ch = popch()))
ch = nhgetch();
return (char) ch;
return 0; /* quit */
func = extcmdlist[idx].ef_funct;
+ if (!wizard && (extcmdlist[idx].flags & WIZMODECMD)) {
+/*JP
+ You("can't do that.");
+*/
+ pline("\82»\82ê\82Í\82Å\82«\82Ü\82¹\82ñ\81D");
+ return 0;
+ }
if (iflags.menu_requested && !accept_menu_prefix(func)) {
- pline("'m' prefix has no effect for this command.");
+#if 0 /*JP:T*/
+ pline("'%s' prefix has no effect for the %s command.",
+ visctrl(Cmd.spkeys[NHKF_REQMENU]),
+ extcmdlist[idx].ef_txt);
+#else
+ pline("'%s'\90Ú\93ª\8e«\82Í%s\83R\83}\83\93\83h\82É\82Í\96³\8cø\81D",
+ visctrl(Cmd.spkeys[NHKF_REQMENU]),
+ extcmdlist[idx].ef_txt);
+#endif
iflags.menu_requested = FALSE;
}
retval = (*func)();
return retval;
}
-/* here after #? - now list all full-word commands */
+/* here after #? - now list all full-word commands and provid
+ some navigation capability through the long list */
int
doextlist(VOID_ARGS)
{
register const struct ext_func_tab *efp;
- char buf[BUFSZ];
- winid datawin;
+ char buf[BUFSZ], searchbuf[BUFSZ], promptbuf[QBUFSZ];
+ winid menuwin;
+ anything any;
+ menu_item *selected;
+ int n, pass;
+ int menumode = 0, menushown[2], onelist = 0;
+ boolean redisplay = TRUE, search = FALSE;
+#if 0 /*JP:T*/
+ static const char *headings[] = { "Extended commands",
+ "Debugging Extended Commands" };
+#else
+ static const char *headings[] = { "\8ag\92£\83R\83}\83\93\83h",
+ "\83f\83o\83b\83O\8ag\92£\83R\83}\83\93\83h" };
+#endif
- datawin = create_nhwindow(NHW_TEXT);
- putstr(datawin, 0, "");
-/*JP
- putstr(datawin, 0, " Extended Commands List");
-*/
- putstr(datawin, 0, " \8ag\92£\83R\83}\83\93\83h\88ê\97\97");
- putstr(datawin, 0, "");
-/*JP
- putstr(datawin, 0, " Press '#', then type:");
-*/
- putstr(datawin, 0, " '#'\82ð\89\9f\82µ\82½\82 \82Æ\83^\83C\83v\82¹\82æ:");
- putstr(datawin, 0, "");
+ searchbuf[0] = '\0';
+ menuwin = create_nhwindow(NHW_MENU);
- for (efp = extcmdlist; efp->ef_txt; efp++) {
- Sprintf(buf, " %-15s - %s.", efp->ef_txt, efp->ef_desc);
- putstr(datawin, 0, buf);
+ while (redisplay) {
+ redisplay = FALSE;
+ any = zeroany;
+ start_menu(menuwin);
+#if 0 /*JP:T*/
+ add_menu(menuwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
+ "Extended Commands List", MENU_UNSELECTED);
+#else
+ add_menu(menuwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
+ "\8ag\92£\83R\83}\83\93\83h\88ê\97\97", MENU_UNSELECTED);
+#endif
+ add_menu(menuwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
+ "", MENU_UNSELECTED);
+
+#if 0 /*JP:T*/
+ Strcpy(buf, menumode ? "Show" : "Hide");
+ Strcat(buf, " commands that don't autocomplete");
+ if (!menumode)
+ Strcat(buf, " (those not marked with [A])");
+#else
+ Strcpy(buf, "\8e©\93®\95â\8a®\82³\82ê\82È\82¢\83R\83}\83\93\83h\82ð");
+ Strcat(buf, menumode ? "\95\\8e¦\82·\82é" : "\95\\8e¦\82µ\82È\82¢ (\82±\82ê\82ç\82Í[A]\83}\81[\83N\82ª\82Â\82©\82È\82¢)");
+#endif
+ any.a_int = 1;
+ add_menu(menuwin, NO_GLYPH, &any, 'a', 0, ATR_NONE, buf,
+ MENU_UNSELECTED);
+
+ 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 */
+#if 0 /*JP:T*/
+ add_menu(menuwin, NO_GLYPH, &any, ':', 's', ATR_NONE,
+ "Search extended commands", MENU_UNSELECTED);
+#else
+ add_menu(menuwin, NO_GLYPH, &any, ':', 's', ATR_NONE,
+ "\8ag\92£\83R\83}\83\93\83h\82ð\8c\9f\8dõ\82·\82é", MENU_UNSELECTED);
+#endif
+ } else {
+#if 0 /*JP:T*/
+ Strcpy(buf, "Show all, clear search");
+#else
+ Strcpy(buf, "\91S\82Ä\95\\8e¦; \8c\9f\8dõ\82ð\83N\83\8a\83A");
+#endif
+ 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, NO_GLYPH, &any, 's', ':', ATR_NONE,
+ buf, MENU_UNSELECTED);
+ }
+ if (wizard) {
+ any.a_int = 4;
+#if 0 /*JP:T*/
+ add_menu(menuwin, NO_GLYPH, &any, 'z', 0, ATR_NONE,
+ onelist ? "Show debugging commands in separate section"
+ : "Show all alphabetically, including debugging commands",
+ MENU_UNSELECTED);
+#else
+ add_menu(menuwin, NO_GLYPH, &any, 'z', 0, ATR_NONE,
+ onelist ? "\83f\83o\83b\83O\83R\83}\83\93\83h\82Í\95Ê\82Ì\90ß\82É\95\\8e¦\82·\82é"
+ : "\83f\83o\83b\83O\83R\83}\83\93\83h\82ð\8aÜ\82Þ\91S\82Ä\82Ì\83R\83}\83\93\83h\82ð\83A\83\8b\83t\83@\83x\83b\83g\8f\87\82É\95\\8e¦\82·\82é",
+ MENU_UNSELECTED);
+#endif
+ }
+ any = zeroany;
+ add_menu(menuwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
+ "", MENU_UNSELECTED);
+ 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) != 0)
+ continue;
+ /* if hiding non-autocomplete commands, skip such */
+ if (menumode == 1 && (efp->flags & AUTOCOMPLETE) == 0)
+ continue;
+ /* if searching, skip this command if it doesn't match */
+ if (*searchbuf
+ /* first try case-insensitive substring match */
+ && !strstri(efp->ef_txt, searchbuf)
+ && !strstri(efp->ef_desc, searchbuf)
+ /* wildcard support; most interfaces use case-insensitve
+ pmatch rather than regexp for menu searching */
+ && !pmatchi(searchbuf, efp->ef_txt)
+ && !pmatchi(searchbuf, efp->ef_desc))
+ 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;
+
+ /* 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(menuwin, NO_GLYPH, &any, 0, 0,
+ iflags.menu_headings, buf, MENU_UNSELECTED);
+ menushown[pass] = 1;
+ }
+ Sprintf(buf, " %-14s %-3s %s",
+ efp->ef_txt,
+ (efp->flags & AUTOCOMPLETE) ? "[A]" : " ",
+ efp->ef_desc);
+ add_menu(menuwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
+ buf, MENU_UNSELECTED);
+ ++n;
+ }
+ if (n)
+ add_menu(menuwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
+ "", MENU_UNSELECTED);
+ }
+ if (*searchbuf && !n)
+#if 0 /*JP:T*/
+ add_menu(menuwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
+ "no matches", MENU_UNSELECTED);
+#else
+ add_menu(menuwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
+ "\88ê\92v\82È\82µ", MENU_UNSELECTED);
+#endif
+
+ 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) {
+#if 0 /*JP:T*/
+ Strcpy(promptbuf, "Extended command list search phrase");
+ Strcat(promptbuf, "?");
+#else
+ Strcpy(promptbuf, "\8ag\92£\83R\83}\83\93\83h\82Ì\8c\9f\8dõ\95¶\8e\9a\97ñ\82Í?");
+#endif
+ getlin(promptbuf, searchbuf);
+ (void) mungspaces(searchbuf);
+ if (searchbuf[0] == '\033')
+ searchbuf[0] = '\0';
+ if (*searchbuf)
+ redisplay = TRUE;
+ search = FALSE;
+ }
}
- display_nhwindow(datawin, FALSE);
- destroy_nhwindow(datawin);
+ destroy_nhwindow(menuwin);
return 0;
}
-#ifdef TTY_GRAPHICS
-#define MAX_EXT_CMD 50 /* Change if we ever have > 50 ext cmds */
+#if defined(TTY_GRAPHICS) || defined(CURSES_GRAPHICS)
+#define MAX_EXT_CMD 200 /* Change if we ever have more ext cmds */
/*
- * This is currently used only by the tty port and is
- * controlled via runtime option 'extmenu'.
+ * 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.
*
char buf[BUFSZ];
char cbuf[QBUFSZ], prompt[QBUFSZ], fmtstr[20];
int i, n, nchoices, acount;
- int ret, biggest;
+ int ret, len, biggest;
int accelerator, prevaccelerator;
int matchlevel = 0;
+ boolean wastoolong, one_per_line;
ret = 0;
cbuf[0] = '\0';
any = zeroany;
/* populate choices */
for (efp = extcmdlist; efp->ef_txt; efp++) {
+ if ((efp->flags & CMD_NOT_AVAILABLE)
+ || !(efp->flags & AUTOCOMPLETE)
+ || (!wizard && (efp->flags & WIZMODECMD)))
+ continue;
if (!matchlevel || !strncmp(efp->ef_txt, cbuf, matchlevel)) {
choices[i] = efp;
- if ((int) strlen(efp->ef_desc) > biggest) {
- biggest = strlen(efp->ef_desc);
- Sprintf(fmtstr, "%%-%ds", biggest + 15);
- }
+ if ((len = (int) strlen(efp->ef_desc)) > biggest)
+ biggest = len;
if (++i > MAX_EXT_CMD) {
-#if defined(BETA)
+#if (NH_DEVEL_STATUS != NH_STATUS_RELEASED)
impossible(
"Exceeded %d extended commands in doextcmd() menu; 'extmenu' disabled.",
MAX_EXT_CMD);
-#endif /* BETA */
+#endif /* NH_DEVEL_STATUS != NH_STATUS_RELEASED */
iflags.extmenu = 0;
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) {
- for (i = 0; extcmdlist[i].ef_txt != (char *) 0; i++)
- if (!strncmpi(extcmdlist[i].ef_txt, cbuf, matchlevel)) {
- ret = i;
- break;
- }
+ if (nchoices <= 1) {
+ ret = (nchoices == 1) ? (int) (choices[0] - extcmdlist) : -1;
break;
}
/* otherwise... */
win = create_nhwindow(NHW_MENU);
start_menu(win);
+ 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);
accelerator = prevaccelerator = 0;
acount = 0;
for (i = 0; choices[i]; ++i) {
accelerator = choices[i]->ef_txt[matchlevel];
- if (accelerator != prevaccelerator || nchoices < (ROWNO - 3)) {
+ 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);
add_menu(win, NO_GLYPH, &any, any.a_char, 0, ATR_NONE,
buf, FALSE);
acount = 0;
+ if (!(accelerator != prevaccelerator || one_per_line))
+ wastoolong = TRUE;
}
}
prevaccelerator = accelerator;
- if (!acount || nchoices < (ROWNO - 3)) {
- Sprintf(prompt, "%s [%s]", choices[i]->ef_txt,
- choices[i]->ef_desc);
+ if (!acount || one_per_line) {
+#if 0 /*JP:T*/
+ Sprintf(prompt, "%s%s [%s]", wastoolong ? "or " : "",
+ choices[i]->ef_txt, choices[i]->ef_desc);
+#else
+ Sprintf(prompt, "%s%s [%s]", wastoolong ? "\82Ü\82½\82Í" : "",
+ choices[i]->ef_txt, choices[i]->ef_desc);
+#endif
} else if (acount == 1) {
-/*JP
- Sprintf(prompt, "%s or %s", choices[i - 1]->ef_txt,
-*/
- Sprintf(prompt, "%s \82Ü\82½\82Í %s", choices[i-1]->ef_txt,
- choices[i]->ef_txt);
+#if 0 /*JP:T*/
+ Sprintf(prompt, "%s%s or %s", wastoolong ? "or " : "",
+ choices[i - 1]->ef_txt, choices[i]->ef_txt);
+#else
+ Sprintf(prompt, "%s%s\82Ü\82½\82Í%s", wastoolong ? "\82Ü\82½\82Í" : "",
+ choices[i - 1]->ef_txt, choices[i]->ef_txt);
+#endif
} else {
/*JP
Strcat(prompt, " or ");
if (n == 1) {
if (matchlevel > (QBUFSZ - 2)) {
free((genericptr_t) pick_list);
-#if defined(BETA)
+#if (NH_DEVEL_STATUS != NH_STATUS_RELEASED)
impossible("Too many chars (%d) entered in extcmd_via_menu()",
matchlevel);
#endif
#endif /* TTY_GRAPHICS */
/* #monster command - use special monster ability while polymorphed */
-STATIC_PTR int
+int
domonability(VOID_ARGS)
{
if (can_breathe(youmonst.data))
return 0;
}
-STATIC_PTR int
-dooverview_or_wiz_where(VOID_ARGS)
-{
- if (wizard)
- return wiz_where();
- else
- dooverview();
- return 0;
-}
-
/* ^W command - wish for something */
STATIC_PTR int
wiz_wish(VOID_ARGS) /* Unlimited wishes for debug mode by Paul Polderman */
flags.verbose = save_verbose;
(void) encumber_msg();
} else
-/*JP
- pline("Unavailable command '%s'.",
-*/
- pline("'%s'\83R\83}\83\93\83h\82Í\8eg\82¦\82È\82¢\81D",
- visctrl((int) cmd_from_func(wiz_wish)));
+ pline(unavailcmd, visctrl((int) cmd_from_func(wiz_wish)));
return 0;
}
{
if (wizard) {
iflags.override_ID = (int) cmd_from_func(wiz_identify);
- if (display_inventory((char *) 0, TRUE) == -1)
- identify_pack(0, FALSE);
+ /* command remapping might leave #wizidentify as the only way
+ to invoke us, in which case cmd_from_func() will yield NUL;
+ it won't matter to display_inventory()/display_pickinv()
+ if ^I invokes some other command--what matters is that
+ display_pickinv() and xname() see override_ID as nonzero */
+ if (!iflags.override_ID)
+ iflags.override_ID = C('I');
+ (void) display_inventory((char *) 0, FALSE);
iflags.override_ID = 0;
} else
-/*JP
- pline("Unavailable command '%s'.",
-*/
- pline("'%s'\83R\83}\83\93\83h\82Í\8eg\82¦\82È\82¢\81D",
- visctrl((int) cmd_from_func(wiz_identify)));
+ pline(unavailcmd, visctrl((int) cmd_from_func(wiz_identify)));
+ return 0;
+}
+
+/* #wizmakemap - discard current dungeon level and replace with a new one */
+STATIC_PTR int
+wiz_makemap(VOID_ARGS)
+{
+ if (wizard) {
+ struct monst *mtmp;
+ boolean was_in_W_tower = In_W_tower(u.ux, u.uy, &u.uz);
+
+ rm_mapseen(ledger_no(&u.uz));
+ for (mtmp = fmon; mtmp; mtmp = mtmp->nmon) {
+ if (mtmp->isgd) { /* vault is going away; get rid of guard */
+ mtmp->isgd = 0;
+ mongone(mtmp);
+ }
+ if (DEADMONSTER(mtmp))
+ continue;
+ if (mtmp->isshk)
+ setpaid(mtmp);
+ /* TODO?
+ * Reduce 'born' tally for each monster about to be discarded
+ * by savelev(), otherwise replacing heavily populated levels
+ * tends to make their inhabitants become extinct.
+ */
+ }
+ if (Punished) {
+ ballrelease(FALSE);
+ unplacebc();
+ }
+ /* reset lock picking unless it's for a carried container */
+ maybe_reset_pick((struct obj *) 0);
+ /* reset interrupted digging if it was taking place on this level */
+ if (on_level(&context.digging.level, &u.uz))
+ (void) memset((genericptr_t) &context.digging, 0,
+ sizeof (struct dig_info));
+ /* reset cached targets */
+ iflags.travelcc.x = iflags.travelcc.y = 0; /* travel destination */
+ context.polearm.hitmon = (struct monst *) 0; /* polearm target */
+ /* escape from trap */
+ reset_utrap(FALSE);
+ check_special_room(TRUE); /* room exit */
+ u.ustuck = (struct monst *) 0;
+ u.uswallow = 0;
+ u.uinwater = 0;
+ u.uundetected = 0; /* not hidden, even if means are available */
+ dmonsfree(); /* purge dead monsters from 'fmon' */
+ /* keep steed and other adjacent pets after releasing them
+ from traps, stopping eating, &c as if hero were ascending */
+ keepdogs(TRUE); /* (pets-only; normally we'd be using 'FALSE' here) */
+
+ /* discard current level; "saving" is used to release dynamic data */
+ savelev(-1, ledger_no(&u.uz), FREE_SAVE);
+ /* create a new level; various things like bestowing a guardian
+ angel on Astral or setting off alarm on Ft.Ludios are handled
+ by goto_level(do.c) so won't occur for replacement levels */
+ mklev();
+
+ vision_reset();
+ vision_full_recalc = 1;
+ cls();
+ /* was using safe_teleds() but that doesn't honor arrival region
+ on levels which have such; we don't force stairs, just area */
+ u_on_rndspot((u.uhave.amulet ? 1 : 0) /* 'going up' flag */
+ | (was_in_W_tower ? 2 : 0));
+ losedogs();
+ kill_genocided_monsters();
+ /* u_on_rndspot() might pick a spot that has a monster, or losedogs()
+ might pick the hero's spot (only if there isn't already a monster
+ there), so we might have to move hero or the co-located monster */
+ if ((mtmp = m_at(u.ux, u.uy)) != 0)
+ u_collide_m(mtmp);
+ initrack();
+ if (Punished) {
+ unplacebc();
+ placebc();
+ }
+ docrt();
+ flush_screen(1);
+ deliver_splev_message(); /* level entry */
+ check_special_room(FALSE); /* room entry */
+#ifdef INSURANCE
+ save_currentstate();
+#endif
+ } else {
+ pline(unavailcmd, "#wizmakemap");
+ }
return 0;
}
HConfusion = save_Hconf;
HHallucination = save_Hhallu;
} else
-/*JP
- pline("Unavailable command '%s'.",
-*/
- pline("'%s'\83R\83}\83\93\83h\82Í\8eg\82¦\82È\82¢\81D",
- visctrl((int) cmd_from_func(wiz_map)));
+ pline(unavailcmd, visctrl((int) cmd_from_func(wiz_map)));
return 0;
}
if (wizard)
(void) create_particular();
else
-/*JP
- pline("Unavailable command '%s'.",
-*/
- pline("'%s'\83R\83}\83\93\83h\82Í\8eg\82¦\82È\82¢\81D",
- visctrl((int) cmd_from_func(wiz_genesis)));
+ pline(unavailcmd, visctrl((int) cmd_from_func(wiz_genesis)));
return 0;
}
if (wizard)
(void) print_dungeon(FALSE, (schar *) 0, (xchar *) 0);
else
-/*JP
- pline("Unavailable command '%s'.",
-*/
- pline("'%s'\83R\83}\83\93\83h\82Í\8eg\82¦\82È\82¢\81D",
- visctrl((int) cmd_from_func(wiz_where)));
+ pline(unavailcmd, visctrl((int) cmd_from_func(wiz_where)));
return 0;
}
if (wizard)
(void) findit();
else
-/*JP
- pline("Unavailable command '%s'.",
-*/
- pline("'%s'\83R\83}\83\93\83h\82Í\8eg\82¦\82È\82¢\81D",
- visctrl((int) cmd_from_func(wiz_detect)));
+ pline(unavailcmd, visctrl((int) cmd_from_func(wiz_detect)));
return 0;
}
if (wizard)
level_tele();
else
-/*JP
- pline("Unavailable command '%s'.",
-*/
- pline("'%s'\83R\83}\83\93\83h\82Í\8eg\82¦\82È\82¢\81D",
- visctrl((int) cmd_from_func(wiz_level_tele)));
- return 0;
-}
-
-/* #monpolycontrol command - choose new form for shapechangers, polymorphees */
-STATIC_PTR int
-wiz_mon_polycontrol(VOID_ARGS)
-{
- iflags.mon_polycontrol = !iflags.mon_polycontrol;
-#if 0 /*JP*/
- pline("Monster polymorph control is %s.",
- iflags.mon_polycontrol ? "on" : "off");
-#else
- pline("\89ö\95¨\82Ì\95Ï\89»\90§\8cä: %s",
- iflags.mon_polycontrol ? "\83I\83\93" : "\83I\83t");
-#endif
+ pline(unavailcmd, visctrl((int) cmd_from_func(wiz_level_tele)));
return 0;
}
STATIC_PTR int
wiz_level_change(VOID_ARGS)
{
- char buf[BUFSZ];
- int newlevel;
+ char buf[BUFSZ] = DUMMY;
+ int newlevel = 0;
int ret;
/*JP
STATIC_PTR int
wiz_panic(VOID_ARGS)
{
-/*JP
- if (yn("Do you want to call panic() and end your game?") == 'y')
-*/
- if (yn("panic()\8aÖ\90\94\82ð\8cÄ\82Ñ\8fo\82µ\82Ä\83Q\81[\83\80\82ð\8fI\97¹\82³\82¹\82Ü\82·\82©\81H") == 'y')
+ if (iflags.debug_fuzzer) {
+ u.uhp = u.uhpmax = 1000;
+ u.uen = u.uenmax = 1000;
+ return 0;
+ }
+#if 0 /*JP:T*/
+ if (paranoid_query(ParanoidQuit,
+ "Do you want to call panic() and end your game?"))
+#else
+ if (paranoid_query(ParanoidQuit,
+ "panic()\8aÖ\90\94\82ð\8cÄ\82Ñ\8fo\82µ\82Ä\83Q\81[\83\80\82ð\8fI\97¹\82³\82¹\82Ü\82·\82©\81H"))
+#endif
panic("Crash test.");
return 0;
}
int x, y;
char row[COLNO + 1];
struct rm *lev;
- boolean istty = !strcmp(windowprocs.name, "tty");
+ boolean istty = WINDOWPORT("tty");
win = create_nhwindow(NHW_TEXT);
if (istty)
for (x = 1; x < COLNO; x++) {
terrain = levl[x][y].typ;
/* assumes there aren't more than 10+26+26 terrain types */
- row[x - 1] = (char) ((terrain == 0 && !may_dig(x, y))
+ row[x - 1] = (char) ((terrain == STONE && !may_dig(x, y))
? '*'
: (terrain < 10)
? '0' + terrain
? 'a' + terrain - 10
: 'A' + terrain - 36);
}
- if (levl[0][y].typ != 0 || may_dig(0, y))
+ x--;
+ if (levl[0][y].typ != STONE || may_dig(0, y))
row[x++] = '!';
row[x] = '\0';
putstr(win, 0, row);
return 0;
}
+/* #wizinstrinsic command to set some intrinsics for testing */
+STATIC_PTR int
+wiz_intrinsic(VOID_ARGS)
+{
+ if (wizard) {
+ extern const struct propname {
+ int prop_num;
+ const char *prop_name;
+ } propertynames[]; /* timeout.c */
+ static const char wizintrinsic[] = "#wizintrinsic";
+ static const char fmt[] = "You are%s %s.";
+ winid win;
+ anything any;
+ char buf[BUFSZ];
+ int i, j, n, p, amt, typ;
+ long oldtimeout, newtimeout;
+ const char *propname;
+ menu_item *pick_list = (menu_item *) 0;
+
+ any = zeroany;
+ win = create_nhwindow(NHW_MENU);
+ start_menu(win);
+ for (i = 0; (propname = propertynames[i].prop_name) != 0; ++i) {
+ p = propertynames[i].prop_num;
+ if (p == HALLUC_RES) {
+ /* Grayswandir vs hallucination; ought to be redone to
+ use u.uprops[HALLUC].blocked instead of being treated
+ as a separate property; letting in be manually toggled
+ even only in wizard mode would be asking for trouble... */
+ continue;
+ }
+ if (p == FIRE_RES) {
+ any.a_int = 0;
+ add_menu(win, NO_GLYPH, &any, 0, 0, ATR_NONE, "--", FALSE);
+ }
+ any.a_int = i + 1; /* +1: avoid 0 */
+ oldtimeout = u.uprops[p].intrinsic & TIMEOUT;
+ if (oldtimeout)
+ Sprintf(buf, "%-27s [%li]", propname, oldtimeout);
+ else
+ Sprintf(buf, "%s", propname);
+ add_menu(win, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
+ }
+ end_menu(win, "Which intrinsics?");
+ n = select_menu(win, PICK_ANY, &pick_list);
+ destroy_nhwindow(win);
+
+ amt = 30; /* TODO: prompt for duration */
+ for (j = 0; j < n; ++j) {
+ i = pick_list[j].item.a_int - 1; /* -1: reverse +1 above */
+ p = propertynames[i].prop_num;
+ oldtimeout = u.uprops[p].intrinsic & TIMEOUT;
+ newtimeout = oldtimeout + (long) amt;
+ switch (p) {
+ case SICK:
+ case SLIMED:
+ case STONED:
+ if (oldtimeout > 0L && newtimeout > oldtimeout)
+ newtimeout = oldtimeout;
+ break;
+ }
+
+ switch (p) {
+ case BLINDED:
+ make_blinded(newtimeout, TRUE);
+ break;
+#if 0 /* make_confused() only gives feedback when confusion is
+ * ending so use the 'default' case for it instead */
+ case CONFUSION:
+ make_confused(newtimeout, TRUE);
+ break;
+#endif /*0*/
+ case DEAF:
+ make_deaf(newtimeout, TRUE);
+ break;
+ case HALLUC:
+ make_hallucinated(newtimeout, TRUE, 0L);
+ break;
+ case SICK:
+ typ = !rn2(2) ? SICK_VOMITABLE : SICK_NONVOMITABLE;
+ make_sick(newtimeout, wizintrinsic, TRUE, typ);
+ break;
+ case SLIMED:
+ Sprintf(buf, fmt,
+ !Slimed ? "" : " still", "turning into slime");
+ make_slimed(newtimeout, buf);
+ break;
+ case STONED:
+ Sprintf(buf, fmt,
+ !Stoned ? "" : " still", "turning into stone");
+ make_stoned(newtimeout, buf, KILLED_BY, wizintrinsic);
+ break;
+ case STUNNED:
+ make_stunned(newtimeout, TRUE);
+ break;
+ case VOMITING:
+ Sprintf(buf, fmt, !Vomiting ? "" : " still", "vomiting");
+ make_vomiting(newtimeout, FALSE);
+ pline1(buf);
+ break;
+ case WARN_OF_MON:
+ if (!Warn_of_mon) {
+ context.warntype.speciesidx = PM_GRID_BUG;
+ context.warntype.species
+ = &mons[context.warntype.speciesidx];
+ }
+ goto def_feedback;
+ case GLIB:
+ /* slippery fingers applies to gloves if worn at the time
+ so persistent inventory might need updating */
+ make_glib((int) newtimeout);
+ goto def_feedback;
+ case LEVITATION:
+ case FLYING:
+ float_vs_flight();
+ /*FALLTHRU*/
+ default:
+ def_feedback:
+ pline("Timeout for %s %s %d.", propertynames[i].prop_name,
+ oldtimeout ? "increased by" : "set to", amt);
+ if (p != GLIB)
+ incr_itimeout(&u.uprops[p].intrinsic, amt);
+ break;
+ }
+ context.botl = 1; /* probably not necessary... */
+ }
+ if (n >= 1)
+ free((genericptr_t) pick_list);
+ doredraw();
+ } else
+ pline(unavailcmd, visctrl((int) cmd_from_func(wiz_intrinsic)));
+ return 0;
+}
+
/* #wizrumorcheck command - verify each rumor access */
STATIC_PTR int
wiz_rumor_check(VOID_ARGS)
* a legend for the levl[][].typ codes dump
*/
men = create_nhwindow(NHW_MENU);
+ start_menu(men);
any = zeroany;
any.a_int = 1;
add_menu(men, NO_GLYPH, &any, 0, 0, ATR_NONE,
+/*JP
"known map without monsters, objects, and traps",
+*/
+ "\89ö\95¨\81C\95¨\81Cã©\82È\82µ\82Ì\92n\90}",
MENU_SELECTED);
any.a_int = 2;
add_menu(men, NO_GLYPH, &any, 0, 0, ATR_NONE,
+/*JP
"known map without monsters and objects",
+*/
+ "\89ö\95¨\81C\95¨\82È\82µ\82Ì\92n\90}",
MENU_UNSELECTED);
any.a_int = 3;
add_menu(men, NO_GLYPH, &any, 0, 0, ATR_NONE,
+/*JP
"known map without monsters",
+*/
+ "\89ö\95¨\82È\82µ\82Ì\92n\90}",
MENU_UNSELECTED);
if (discover || wizard) {
any.a_int = 4;
add_menu(men, NO_GLYPH, &any, 0, 0, ATR_NONE,
+/*JP
"full map without monsters, objects, and traps",
+*/
+ "\89ö\95¨\81C\95¨\81Cã©\82È\82µ\82Ì\8a®\91S\82È\92n\90}",
MENU_UNSELECTED);
if (wizard) {
any.a_int = 5;
MENU_UNSELECTED);
}
}
+/*JP
end_menu(men, "View which?");
+*/
+ end_menu(men, "\82Ç\82ê\82ð\8c©\82é\81H");
n = select_menu(men, PICK_ONE, &sel);
destroy_nhwindow(men);
free((genericptr_t) sel);
switch (which) {
- case 1: reveal_terrain(0, 0); break; /* known map */
- case 2: reveal_terrain(0, 1); break; /* known map with traps */
- case 3: reveal_terrain(0, 1|2); break; /* known map w/ traps & objs */
- case 4: reveal_terrain(1, 0); break; /* full map */
- case 5: wiz_map_levltyp(); break; /* map internals */
- case 6: wiz_levltyp_legend(); break; /* internal details */
- default: break;
+ case 1: /* known map */
+ reveal_terrain(0, TER_MAP);
+ break;
+ case 2: /* known map with known traps */
+ reveal_terrain(0, TER_MAP | TER_TRP);
+ break;
+ case 3: /* known map with known traps and objects */
+ reveal_terrain(0, TER_MAP | TER_TRP | TER_OBJ);
+ break;
+ case 4: /* full map */
+ reveal_terrain(1, TER_MAP);
+ break;
+ case 5: /* map internals */
+ wiz_map_levltyp();
+ break;
+ case 6: /* internal details */
+ wiz_levltyp_legend();
+ break;
+ default:
+ break;
}
return 0; /* no time elapses */
}
/* -enlightenment and conduct- */
static winid en_win = WIN_ERR;
+static boolean en_via_menu = FALSE;
#if 0 /*JP*/
static const char You_[] = "You ", are[] = "are ", were[] = "were ",
have[] = "have ", had[] = "had ", can[] = "can ",
enlght_line(prefix, final ? past : present, suffix, ps)
#else
#define enl_msg(prefix, present, past, suffix, ps) \
- enlght_line(prefix, suffix, final ? past : present, ps)
+ enlght_line(prefix, ps, suffix, final ? past : present)
#endif
#define you_are(attr, ps) enl_msg(You_, are, were, attr, ps)
#define you_have(attr, ps) enl_msg(You_, have, had, attr, ps)
enl_msg(something, "\82Ä\82¢\82é", "\82½", "", "")
#endif
#if 1 /*JP*/
-#define you_are_ing(goodthing) enl_msg(You_, iru, ita, goodthing, "")
+#define you_are_ing(goodthing, ps) enl_msg(You_, iru, ita, goodthing, ps)
#endif
static void
+enlght_out(buf)
+const char *buf;
+{
+ if (en_via_menu) {
+ anything any;
+
+ any = zeroany;
+ add_menu(en_win, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
+ } else
+ putstr(en_win, 0, buf);
+}
+
+static void
enlght_line(start, middle, end, ps)
const char *start, *middle, *end, *ps;
{
Sprintf(buf, " %s%s%s%s.", start, middle, end, ps);
*/
Sprintf(buf, "%s%s%s%s\81D", start, middle, end, ps);
- putstr(en_win, 0, buf);
+ enlght_out(buf);
}
/* format increased chance to hit or damage or defense (Protection) */
char *outbuf;
{
const char *modif, *bonus;
+#if 0 /*JP*/
boolean invrt;
+#endif
int absamt;
absamt = abs(incamt);
/* Protection amount is typically larger than damage or to-hit;
reduce magnitude by a third in order to stretch modifier ranges
(small:1..5, moderate:6..10, large:11..19, huge:20+) */
+#if 0 /*JP:T*/
if (!strcmp(inctyp, "defense"))
+#else
+ if (!strcmp(inctyp, "\96h\8cä"))
+#endif
absamt = (absamt * 2) / 3;
if (absamt <= 3)
*/
bonus = (incamt > 0) ? "\83{\81[\83i\83X" : "\83y\83i\83\8b\83e\83B";
/* "bonus <foo>" (to hit) vs "<bar> bonus" (damage, defense) */
+#if 0 /*JP*/
invrt = strcmp(inctyp, "to hit") ? TRUE : FALSE;
+#endif
#if 0 /*JP*/
Sprintf(outbuf, "%s %s %s", modif, invrt ? inctyp : bonus,
switch (category) {
case HALF_PHDAM:
+/*JP
category_name = "physical";
+*/
+ category_name = "\95¨\97\9d";
break;
case HALF_SPDAM:
+/*JP
category_name = "spell";
+*/
+ category_name = "\8eô\95¶";
break;
default:
+/*JP
category_name = "unknown";
+*/
+ category_name = "\95s\96¾";
break;
}
+#if 0 /*JP:T*/
Sprintf(buf, " %s %s damage", (final || wizard) ? "half" : "reduced",
category_name);
enl_msg(You_, "take", "took", buf, from_what(category));
+#else
+ Sprintf(buf, " %s\83_\83\81\81[\83W\82ð%s", (final || wizard) ? "\94¼\8c¸" : "\8c¸\8f",
+ category_name);
+ enl_msg(You_, "\82µ\82Ä\82¢\82é", "\82µ\82Ä\82¢\82½", buf, from_what(category));
+#endif
}
/* is hero actively using water walking capability on water (or lava)? */
{
char buf[BUFSZ], tmpbuf[BUFSZ];
+ en_win = create_nhwindow(NHW_MENU);
+ en_via_menu = !final;
+ if (en_via_menu)
+ start_menu(en_win);
+
Strcpy(tmpbuf, plname);
*tmpbuf = highc(*tmpbuf); /* same adjustment as bottom line */
/* as in background_enlightenment, when poly'd we need to use the saved
gender in u.mfemale rather than the current you-as-monster gender */
-#if 0 /*JP*/
+#if 0 /*JP:T*/
Sprintf(buf, "%s the %s's attributes:", tmpbuf,
((Upolyd ? u.mfemale : flags.female) && urole.name.f)
? urole.name.f
tmpbuf);
#endif
- en_win = create_nhwindow(NHW_MENU);
/* title */
- putstr(en_win, 0, buf); /* "Conan the Archeologist's attributes:" */
+ enlght_out(buf); /* "Conan the Archeologist's attributes:" */
/* background and characteristics; ^X or end-of-game disclosure */
if (mode & BASICENLIGHTENMENT) {
- /* role, race, alignment, deities */
+ /* role, race, alignment, deities, dungeon level, time, experience */
background_enlightenment(mode, final);
+ /* hit points, energy points, armor class, gold */
+ basics_enlightenment(mode, final);
/* strength, dexterity, &c */
characteristics_enlightenment(mode, final);
}
/* intrinsics and other traditional enlightenment feedback */
attributes_enlightenment(mode, final);
}
- display_nhwindow(en_win, TRUE);
+
+ if (!en_via_menu) {
+ display_nhwindow(en_win, TRUE);
+ } else {
+ menu_item *selected = 0;
+
+ end_menu(en_win, (char *) 0);
+ if (select_menu(en_win, PICK_NONE, &selected) > 0)
+ free((genericptr_t) selected);
+ en_via_menu = FALSE;
+ }
destroy_nhwindow(en_win);
en_win = WIN_ERR;
}
role_titl = (innategend && urole.name.f) ? urole.name.f : urole.name.m;
rank_titl = rank_of(u.ulevel, Role_switch, innategend);
- putstr(en_win, 0, ""); /* separator after title */
+ enlght_out(""); /* separator after title */
/*JP
- putstr(en_win, 0, "Background:");
+ enlght_out("Background:");
*/
- putstr(en_win, 0, "\94w\8ci\8fî\95ñ:");
+ enlght_out("\94w\8ci\8fî\95ñ:");
/* if polymorphed, report current shape before underlying role;
will be repeated as first status: "you are transformed" and also
/*JP
Sprintf(tmpbuf, "%s ", genders[flags.female ? 1 : 0].adj);
*/
- Sprintf(tmpbuf, "%s", genders[flags.female ? 1 : 0].adj);
+ Sprintf(tmpbuf, "%s\82Ì", genders[flags.female ? 1 : 0].adj);
+#if 0 /*JP:T*/
Sprintf(buf, "%sin %s%s form", !final ? "currently " : "", tmpbuf,
uasmon->mname);
+#else
+ Sprintf(buf, "%s%s%s\82Ì\8ep", !final ? "\8d¡\82Ì\82Æ\82±\82ë" : "", tmpbuf,
+ uasmon->mname);
+#endif
+/*JP
you_are(buf, "");
+*/
+ you_are_ing(buf, "");
}
/* report role; omit gender if it's redundant (eg, "female priestess") */
Sprintf(tmpbuf, "%s", genders[innategend].adj);
buf[0] = '\0';
if (Upolyd)
+#if 0 /*JP:T*/
Strcpy(buf, "actually "); /* "You are actually a ..." */
+#else
+ Strcpy(buf, "\8eÀ\8dÛ\82É\82Í"); /* "\82 \82È\82½\82Í\8eÀ\8dÛ\82É\82Í..." */
+#endif
if (!strcmpi(rank_titl, role_titl)) {
/* omit role when rank title matches it */
-#if 0 /*JP*/
+#if 0 /*JP:T*/
Sprintf(eos(buf), "%s, level %d %s%s", an(rank_titl), u.ulevel,
tmpbuf, urace.noun);
#else
tmpbuf, urace.adj, role_titl);
#endif
} else {
-#if 0 /*JP*/
+#if 0 /*JP:T*/
Sprintf(eos(buf), "%s, a level %d %s%s %s", an(rank_titl), u.ulevel,
tmpbuf, urace.adj, role_titl);
#else
}
you_are(buf, "");
- /* report alignment (bypass you_are() in order to omit ending period) */
+ /* report alignment (bypass you_are() in order to omit ending period);
+ adverb is used to distinguish between temporary change (helm of opp.
+ alignment), permanent change (one-time conversion), and original */
#if 0 /*JP*/
Sprintf(buf, " %s%s%s, %son a mission for %s",
You_, !final ? are : were,
align_str(u.ualign.type),
/* helm of opposite alignment (might hide conversion) */
- (u.ualign.type != u.ualignbase[A_CURRENT]) ? "temporarily "
+ (u.ualign.type != u.ualignbase[A_CURRENT])
+ /* what's the past tense of "currently"? if we used "formerly"
+ it would sound like a reference to the original alignment */
+ ? (!final ? "currently " : "temporarily ")
/* permanent conversion */
- : (u.ualign.type != u.ualignbase[A_ORIGINAL]) ? "now "
+ : (u.ualign.type != u.ualignbase[A_ORIGINAL])
+ /* and what's the past tense of "now"? certainly not "then"
+ in a context like this...; "belatedly" == weren't that
+ way sooner (in other words, didn't start that way) */
+ ? (!final ? "now " : "belatedly ")
/* atheist (ignored in very early game) */
- : (!u.uconduct.gnostic && moves > 1000L) ? "nominally "
+ : (!u.uconduct.gnostic && moves > 1000L)
+ ? "nominally "
/* lastly, normal case */
: "",
u_gname());
#else
- Sprintf(buf, " \82 \82È\82½\82Í%s\82Å, %s%s\82Ì\82½\82ß\82Ì\94C\96±\82ð\8ds\82Á\82Ä%s",
+ Sprintf(buf, "\82 \82È\82½\82Í%s\82Å, %s%s\82Ì\82½\82ß\82Ì\94C\96±\82ð\8ds\82Á\82Ä%s\81D",
align_str(u.ualign.type),
/* helm of opposite alignment (might hide conversion) */
(u.ualign.type != u.ualignbase[A_CURRENT]) ? "\88ê\8e\9e\93I\82É"
: "",
u_gname(), !final ? iru : ita);
#endif
- putstr(en_win, 0, buf);
+ enlght_out(buf);
/* show the rest of this game's pantheon (finishes previous sentence)
[appending "also Moloch" at the end would allow for straightforward
trailing "and" on all three aligned entries but looks too verbose] */
Strcpy(buf, "\82 \82È\82½\82Í");
#endif
if (u.ualign.type != A_LAWFUL)
-#if 0 /*JP*/
+#if 0 /*JP:T*/
Sprintf(eos(buf), " %s (%s) and", align_gname(A_LAWFUL),
align_str(A_LAWFUL));
#else
align_str(A_LAWFUL));
#endif
if (u.ualign.type != A_NEUTRAL)
-#if 0 /*JP*/
+#if 0 /*JP:T*/
Sprintf(eos(buf), " %s (%s)%s", align_gname(A_NEUTRAL),
align_str(A_NEUTRAL),
(u.ualign.type != A_CHAOTIC) ? " and" : "");
align_str(A_NEUTRAL),
(u.ualign.type != A_CHAOTIC) ? "\82¨\82æ\82Ñ" : "");
#endif
-#if 0 /*JP*/
if (u.ualign.type != A_CHAOTIC)
+#if 0 /*JP:T*/
Sprintf(eos(buf), " %s (%s)", align_gname(A_CHAOTIC),
align_str(A_CHAOTIC));
#else
#else
Sprintf(eos(buf), "\82Æ\91Î\97§\82µ\82Ä%s\81D", !final ? iru : ita);
#endif
- putstr(en_win, 0, buf);
+ enlght_out(buf);
/* show original alignment,gender,race,role if any have been changed;
giving separate message for temporary alignment change bypasses need
+ ((u.ualignbase[A_CURRENT] != u.ualignbase[A_ORIGINAL])
? 2 : 0));
if (difalgn & 1) { /* have temporary alignment so report permanent one */
+/*JP
Sprintf(buf, "actually %s", align_str(u.ualignbase[A_CURRENT]));
+*/
+ Sprintf(buf, "\8eÀ\8dÛ\82É\82Í%s", align_str(u.ualignbase[A_CURRENT]));
+#if 0 /*JP*/
you_are(buf, "");
+#else
+ enl_msg(buf, "\82Ä\82¢\82é", "\82Ä\82¢\82½", "", "");
+#endif
difalgn &= ~1; /* suppress helm from "started out <foo>" message */
}
if (difgend || difalgn) { /* sex change or perm align change or both */
+#if 0 /*JP:T*/
Sprintf(buf, " You started out %s%s%s.",
difgend ? genders[flags.initgend].adj : "",
(difgend && difalgn) ? " and " : "",
difalgn ? align_str(u.ualignbase[A_ORIGINAL]) : "");
- putstr(en_win, 0, buf);
- }
+#else
+ Sprintf(buf, "\82 \82È\82½\82Í%s%s%s\82Å\8aJ\8en\82µ\82½\81D",
+ difgend ? genders[flags.initgend].adj : "",
+ (difgend && difalgn) ? "\82©\82Â" : "",
+ difalgn ? align_str(u.ualignbase[A_ORIGINAL]) : "");
+#endif
+ enlght_out(buf);
+ }
+
+ /* As of 3.6.2: dungeon level, so that ^X really has all status info as
+ claimed by the comment below; this reveals more information than
+ the basic status display, but that's one of the purposes of ^X;
+ similar information is revealed by #overview; the "You died in
+ <location>" given by really_done() is more rudimentary than this */
+ *buf = *tmpbuf = '\0';
+ if (In_endgame(&u.uz)) {
+ int egdepth = observable_depth(&u.uz);
+
+ (void) endgamelevelname(tmpbuf, egdepth);
+#if 0 /*JP*/
+ Sprintf(buf, "in the endgame, on the %s%s",
+ !strncmp(tmpbuf, "Plane", 5) ? "Elemental " : "", tmpbuf);
+#else
+ Sprintf(buf, "\8dÅ\8fI\8e\8e\97û\82Ì%s", tmpbuf);
+#endif
+ } else if (Is_knox(&u.uz)) {
+ /* this gives away the fact that the knox branch is only 1 level */
+/*JP
+ Sprintf(buf, "on the %s level", dungeons[u.uz.dnum].dname);
+*/
+ Sprintf(buf, "%s", dungeons[u.uz.dnum].dname);
+ /* TODO? maybe phrase it differently when actually inside the fort,
+ if we're able to determine that (not trivial) */
+ } else {
+ char dgnbuf[QBUFSZ];
+
+ Strcpy(dgnbuf, dungeons[u.uz.dnum].dname);
+#if 0 /*JP*/
+ if (!strncmpi(dgnbuf, "The ", 4))
+ *dgnbuf = lowc(*dgnbuf);
+#endif
+#if 0 /*JP*/
+ Sprintf(tmpbuf, "level %d",
+ In_quest(&u.uz) ? dunlev(&u.uz) : depth(&u.uz));
+#else
+ if (In_quest(&u.uz)) {
+ Sprintf(tmpbuf, "\91æ%d\8aK\91w", dunlev(&u.uz));
+ } else {
+ Sprintf(tmpbuf, "\92n\89º%d\8aK", depth(&u.uz));
+ }
+#endif
+ /* TODO? maybe extend this bit to include various other automatic
+ annotations from the dungeon overview code */
+ if (Is_rogue_level(&u.uz))
+/*JP
+ Strcat(tmpbuf, ", a primitive area");
+*/
+ Strcat(tmpbuf, ", \92P\8f\83\82È\90¢\8aE");
+ else if (Is_bigroom(&u.uz) && !Blind)
+/*JP
+ Strcat(tmpbuf, ", a very big room");
+*/
+ Strcat(tmpbuf, ", \82Æ\82Ä\82à\91å\82«\82È\95\94\89®");
+#if 0 /*JP*/
+ Sprintf(buf, "in %s, on %s", dgnbuf, tmpbuf);
+#else
+ Sprintf(buf, "%s\82Ì%s", dgnbuf, tmpbuf);
+#endif
+ }
+ you_are(buf, "");
+
+ /* this is shown even if the 'time' option is off */
+ if (moves == 1L) {
+#if 0 /*JP*/
+ you_have("just started your adventure", "");
+#else
+ enlght_line(You_, "", "\96`\8c¯\82ð\8aJ\8en\82µ\82½\82Æ\82±\82ë\82¾", "");
+#endif
+ } else {
+ /* 'turns' grates on the nerves in this context... */
+/*JP
+ Sprintf(buf, "the dungeon %ld turn%s ago", moves, plur(moves));
+*/
+ Sprintf(buf, "%ld\83^\81[\83\93\91O\82É\96À\8b{\82É\93ü\82Á\82½", moves);
+ /* same phrasing for current and final: "entered" is unconditional */
+#if 0 /*JP*/
+ enlght_line(You_, "entered ", buf, "");
+#else
+ enlght_line(You_, "", buf, "");
+#endif
+ }
+
+ /* for gameover, these have been obtained in really_done() so that they
+ won't vary if user leaves a disclosure prompt or --More-- unanswered
+ long enough for the dynamic value to change between then and now */
+ if (final ? iflags.at_midnight : midnight()) {
+#if 0 /*JP:T*/
+ enl_msg("It ", "is ", "was ", "the midnight hour", "");
+#else
+ enl_msg("\8e\9e\8aÔ\91Ñ\82Í\90[\96é", "\82¾", "\82¾\82Á\82½", "", "");
+#endif
+ } else if (final ? iflags.at_night : night()) {
+#if 0 /*JP:T*/
+ enl_msg("It ", "is ", "was ", "nighttime", "");
+#else
+ enl_msg("\8e\9e\8aÔ\91Ñ\82Í\96é", "\82¾", "\82¾\82Á\82½", "", "");
+#endif
+ }
+ /* other environmental factors */
+ if (flags.moonphase == FULL_MOON || flags.moonphase == NEW_MOON) {
+ /* [This had "tonight" but has been changed to "in effect".
+ There is a similar issue to Friday the 13th--it's the value
+ at the start of the current session but that session might
+ have dragged on for an arbitrary amount of time. We want to
+ report the values that currently affect play--or affected
+ play when game ended--rather than actual outside situation.] */
+#if 0 /*JP:T*/
+ Sprintf(buf, "a %s moon in effect%s",
+ (flags.moonphase == FULL_MOON) ? "full"
+ : (flags.moonphase == NEW_MOON) ? "new"
+ /* showing these would probably just lead to confusion
+ since they have no effect on game play... */
+ : (flags.moonphase < FULL_MOON) ? "first quarter"
+ : "last quarter",
+ /* we don't have access to 'how' here--aside from survived
+ vs died--so settle for general platitude */
+ final ? " when your adventure ended" : "");
+ enl_msg("There ", "is ", "was ", buf, "");
+#else
+ Sprintf(buf, "%s%s\8c\8e",
+ /* we don't have access to 'how' here--aside from survived
+ vs died--so settle for general platitude */
+ final ? "\96`\8c¯\82ð\8fI\82¦\82½\82Æ\82«\81C" : "",
+ (flags.moonphase == FULL_MOON) ? "\96\9e"
+ : (flags.moonphase == NEW_MOON) ? "\90V"
+ /* showing these would probably just lead to confusion
+ since they have no effect on game play... */
+ : (flags.moonphase < FULL_MOON) ? "\8fã\8c·\82Ì"
+ : "\89º\8c·\82Ì");
+ enl_msg("", "\82¾", "\82¾\82Á\82½", buf, "");
+#endif
+ }
+ if (flags.friday13) {
+ /* let player know that friday13 penalty is/was in effect;
+ we don't say "it is/was Friday the 13th" because that was at
+ the start of the session and it might be past midnight (or
+ days later if the game has been paused without save/restore),
+ so phrase this similar to the start up message */
+#if 0 /*JP:T*/
+ Sprintf(buf, " Bad things %s on Friday the 13th.",
+ !final ? "can happen"
+ : (final == ENL_GAMEOVERALIVE) ? "could have happened"
+ /* there's no may to tell whether -1 Luck made a
+ difference but hero has died... */
+ : "happened");
+#else
+ Sprintf(buf, "\82P\82R\93ú\82Ì\8bà\97j\93ú\82É\82Í\82æ\82\82È\82¢\82±\82Æ\82ª%s\81D",
+ !final ? "\82 \82é"
+ : (final == ENL_GAMEOVERALIVE) ? "\82 \82Á\82½\82©\82à\82µ\82ê\82È\82¢"
+ /* there's no may to tell whether -1 Luck made a
+ difference but hero has died... */
+ : "\82 \82Á\82½");
+#endif
+ enlght_out(buf);
+ }
+
+ if (!Upolyd) {
+ int ulvl = (int) u.ulevel;
+ /* [flags.showexp currently does not matter; should it?] */
+
+ /* experience level is already shown above */
+#if 0 /*JP*/
+ Sprintf(buf, "%-1ld experience point%s", u.uexp, plur(u.uexp));
+#else
+ Sprintf(buf, "\8co\8c±\92l%-1ld\83|\83C\83\93\83g", u.uexp);
+#endif
+ /* TODO?
+ * Remove wizard-mode restriction since patient players can
+ * determine the numbers needed without resorting to spoilers
+ * (even before this started being disclosed for 'final';
+ * just enable 'showexp' and look at normal status lines
+ * after drinking gain level potions or eating wraith corpses
+ * or being level-drained by vampires).
+ */
+ if (ulvl < 30 && (final || wizard)) {
+ long nxtlvl = newuexp(ulvl), delta = nxtlvl - u.uexp;
+
+#if 0 /*JP*/
+ Sprintf(eos(buf), ", %ld %s%sneeded %s level %d",
+ delta, (u.uexp > 0) ? "more " : "",
+ /* present tense=="needed", past tense=="were needed" */
+ !final ? "" : (delta == 1L) ? "was " : "were ",
+ /* "for": grammatically iffy but less likely to wrap */
+ (ulvl < 18) ? "to attain" : "for", (ulvl + 1));
+#else
+ Sprintf(eos(buf), "(\83\8c\83x\83\8b%d\82Ü\82Å%ld\83|\83C\83\93\83g)",
+ (ulvl + 1), delta);
+#endif
+ }
+ you_have(buf, "");
+ }
+#ifdef SCORE_ON_BOTL
+ if (flags.showscore) {
+ /* describes what's shown on status line, which is an approximation;
+ only show it here if player has the 'showscore' option enabled */
+#if 0 /*JP*/
+ Sprintf(buf, "%ld%s", botl_score(),
+ !final ? "" : " before end-of-game adjustments");
+ enl_msg("Your score ", "is ", "was ", buf, "");
+#else
+ Sprintf(buf, "%s%ld", botl_score(),
+ !final ? "" : "\83Q\81[\83\80\8fI\97¹\8e\9e\82Ì\92²\90®\91O\82Í");
+ enl_msg("\82 \82È\82½\82Ì\83X\83R\83A\82Í", "\82Å\82 \82é", "\82Å\82 \82Á\82½", buf, "");
+#endif
+ }
+#endif
+}
+
+/* hit points, energy points, armor class -- essential information which
+ doesn't fit very well in other categories */
+/*ARGSUSED*/
+STATIC_OVL void
+basics_enlightenment(mode, final)
+int mode UNUSED;
+int final;
+{
+#if 0 /*JP*//*unused*/
+ static char Power[] = "energy points (spell power)";
+#endif
+ char buf[BUFSZ];
+ int pw = u.uen, hp = (Upolyd ? u.mh : u.uhp),
+ pwmax = u.uenmax, hpmax = (Upolyd ? u.mhmax : u.uhpmax);
+
+ enlght_out(""); /* separator after background */
+/*JP
+ enlght_out("Basics:");
+*/
+ enlght_out("\8aî\96{:");
+
+ if (hp < 0)
+ hp = 0;
+ /* "1 out of 1" rather than "all" if max is only 1; should never happen */
+#if 0 /*JP*/
+ if (hp == hpmax && hpmax > 1)
+ Sprintf(buf, "all %d hit points", hpmax);
+ else
+ Sprintf(buf, "%d out of %d hit point%s", hp, hpmax, plur(hpmax));
+#else
+ Sprintf(buf, "%d\83q\83b\83g\83|\83C\83\93\83g(\8dÅ\91å:%d)", hp, hpmax);
+#endif
+ you_have(buf, "");
+
+ /* low max energy is feasible, so handle couple of extra special cases */
+#if 0 /*JP*/
+ if (pwmax == 0 || (pw == pwmax && pwmax == 2)) /* both: "all 2" is silly */
+ Sprintf(buf, "%s %s", !pwmax ? "no" : "both", Power);
+ else if (pw == pwmax && pwmax > 2)
+ Sprintf(buf, "all %d %s", pwmax, Power);
+ else
+ Sprintf(buf, "%d out of %d %s", pw, pwmax, Power);
+#else
+ Sprintf(buf, "%d\96\82\97Í\83|\83C\83\93\83g(\8dÅ\91å:%d)", pw, pwmax);
+#endif
+ you_have(buf, "");
+
+ if (Upolyd) {
+ switch (mons[u.umonnum].mlevel) {
+ case 0:
+ /* status line currently being explained shows "HD:0" */
+/*JP
+ Strcpy(buf, "0 hit dice (actually 1/2)");
+*/
+ Strcpy(buf, "HD0(\8eÀ\8dÛ\82É\82Í1/2)");
+ break;
+ case 1:
+/*JP
+ Strcpy(buf, "1 hit die");
+*/
+ Strcpy(buf, "HD1");
+ break;
+ default:
+/*JP
+ Sprintf(buf, "%d hit dice", mons[u.umonnum].mlevel);
+*/
+ Sprintf(buf, "HD%d", mons[u.umonnum].mlevel);
+ break;
+ }
+ you_have(buf, "");
+ }
+
+ Sprintf(buf, "%d", u.uac);
+/*JP
+ enl_msg("Your armor class ", "is ", "was ", buf, "");
+*/
+ enl_msg("\82 \82È\82½\82Ì\96h\8cä\92l\82Í", "\82Å\82 \82é", "\82Å\82 \82Á\82½", buf, "");
+
+ /* gold; similar to doprgold(#seegold) but without shop billing info;
+ same amount as shown on status line which ignores container contents */
+ {
+/*JP
+ static const char Your_wallet[] = "Your wallet ";
+*/
+ static const char Your_wallet[] = "\82 \82È\82½\82Ì\8dà\95z";
+ long umoney = money_cnt(invent);
+
+ if (!umoney) {
+/*JP
+ enl_msg(Your_wallet, "is ", "was ", "empty", "");
+*/
+ enl_msg(Your_wallet, "\82Å\82 \82é", "\82¾\82Á\82½", "\82Í\8bó", "");
+ } else {
+#if 0 /*JP:T*/
+ Sprintf(buf, "%ld %s", umoney, currency(umoney));
+ enl_msg(Your_wallet, "contains ", "contained ", buf, "");
+#else
+ Sprintf(buf, "\82É\82Í%ld%s", umoney, currency(umoney));
+ enl_msg(Your_wallet, "\93ü\82Á\82Ä\82¢\82é", "\93ü\82Á\82Ä\82¢\82½", buf, "");
+#endif
+ }
+ }
+
+ if (flags.pickup) {
+ char ocl[MAXOCLASSES + 1];
+
+#if 0 /*JP*//*\8cã\82É\89ñ\82·*/
+ Strcpy(buf, "on");
+#endif
+ oc_to_str(flags.pickup_types, ocl);
+#if 0 /*JP*/
+ Sprintf(eos(buf), " for %s%s%s",
+ *ocl ? "'" : "", *ocl ? ocl : "all types", *ocl ? "'" : "");
+#else
+ Sprintf(buf, "%s%s%s",
+ *ocl ? "'" : "", *ocl ? ocl : "\91S\82Ä\82Ì\8eí\97Þ", *ocl ? "'" : "");
+#endif
+ if (flags.pickup_thrown && *ocl) /* *ocl: don't show if 'all types' */
+/*JP
+ Strcat(buf, " plus thrown");
+*/
+ Strcat(buf, "\82É\89Á\82¦\82Ä\93\8a\82°\82é\82à\82Ì");
+ if (apelist)
+/*JP
+ Strcat(buf, ", with exceptions");
+*/
+ Strcat(buf, "(\97á\8aO\82 \82è)");
+#if 1 /*JP*/
+ Strcat(buf, "\82É\91Î\82µ\82Ä\83I\83\93");
+#endif
+ } else
+/*JP
+ Strcpy(buf, "off");
+*/
+ Strcpy(buf, "\83I\83t");
+/*JP
+ enl_msg("Autopickup ", "is ", "was ", buf, "");
+*/
+ enl_msg("\8e©\93®\8fE\82¢\90Ý\92è\82Í", "\82Å\82 \82é", "\82Å\82 \82Á\82½", buf, "");
}
/* characteristics: expanded version of bottom line strength, dexterity, &c */
int mode;
int final;
{
- putstr(en_win, 0, ""); /* separator after background */
- putstr(en_win, 0,
+ char buf[BUFSZ];
+
+ enlght_out("");
/*JP
- final ? "Final Characteristics:" : "Current Characteristics:");
+ Sprintf(buf, "%s Characteristics:", !final ? "Current" : "Final");
*/
- final ? "\8dÅ\8fI\91®\90«\81F" : "\8c»\8dÝ\82Ì\91®\90«\81F");
+ Sprintf(buf, "%s\93Á\90«\81F", !final ? "\8c»\8dÝ\82Ì" : "\8dÅ\8fI");
+ enlght_out(buf);
/* bottom line order */
one_characteristic(mode, final, A_STR); /* strength */
one_characteristic(mode, final, attrindx)
int mode, final, attrindx;
{
+ extern const char *const attrname[]; /* attrib.c */
boolean hide_innate_value = FALSE, interesting_alimit;
int acurrent, abase, apeak, alimit;
- const char *attrname, *paren_pfx;
+ const char *paren_pfx;
char subjbuf[BUFSZ], valubuf[BUFSZ], valstring[32];
/* being polymorphed or wearing certain cursed items prevents
}
switch (attrindx) {
case A_STR:
- attrname = "strength";
if (uarmg && uarmg->otyp == GAUNTLETS_OF_POWER && uarmg->cursed)
hide_innate_value = TRUE;
break;
case A_DEX:
- attrname = "dexterity";
break;
case A_CON:
- attrname = "constitution";
+ if (uwep && uwep->oartifact == ART_OGRESMASHER && uwep->cursed)
+ hide_innate_value = TRUE;
break;
case A_INT:
- attrname = "intelligence";
if (uarmh && uarmh->otyp == DUNCE_CAP && uarmh->cursed)
hide_innate_value = TRUE;
break;
case A_WIS:
- attrname = "wisdom";
if (uarmh && uarmh->otyp == DUNCE_CAP && uarmh->cursed)
hide_innate_value = TRUE;
break;
case A_CHA:
- attrname = "charisma";
break;
default:
return; /* impossible */
acurrent = ACURR(attrindx);
(void) attrval(attrindx, acurrent, valubuf); /* Sprintf(valubuf,"%d",) */
- Sprintf(subjbuf, "Your %s ", attrname);
+/*JP
+ Sprintf(subjbuf, "Your %s ", attrname[attrindx]);
+*/
+ Sprintf(subjbuf, "\82 \82È\82½\82Ì%s\82Í", attrname[attrindx]);
if (!hide_innate_value) {
/* show abase, amax, and/or attrmax if acurr doesn't match abase
interesting_alimit =
final ? TRUE /* was originally `(abase != alimit)' */
: (alimit != (attrindx != A_STR ? 18 : STR18(100)));
+/*JP
paren_pfx = final ? " (" : " (current; ";
+*/
+ paren_pfx = final ? " (" : " (\8c»\8dÝ; ";
if (acurrent != abase) {
+#if 0 /*JP:T*/
Sprintf(eos(valubuf), "%sbase:%s", paren_pfx,
attrval(attrindx, abase, valstring));
+#else
+ Sprintf(eos(valubuf), "%s\8aî\96{:%s", paren_pfx,
+ attrval(attrindx, abase, valstring));
+#endif
paren_pfx = ", ";
}
if (abase != apeak) {
+#if 0 /*JP:T*/
Sprintf(eos(valubuf), "%speak:%s", paren_pfx,
attrval(attrindx, apeak, valstring));
+#else
+ Sprintf(eos(valubuf), "%s\8dÅ\91å:%s", paren_pfx,
+ attrval(attrindx, apeak, valstring));
+#endif
paren_pfx = ", ";
}
if (interesting_alimit) {
+#if 0 /*JP:T*/
Sprintf(eos(valubuf), "%s%slimit:%s", paren_pfx,
/* more verbose if exceeding 'limit' due to magic bonus */
(acurrent > alimit) ? "innate " : "",
attrval(attrindx, alimit, valstring));
+#else
+ Sprintf(eos(valubuf), "%s%s\8fã\8cÀ:%s", paren_pfx,
+ /* more verbose if exceeding 'limit' due to magic bonus */
+ (acurrent > alimit) ? "\96{\97\88\82Ì" : "",
+ attrval(attrindx, alimit, valstring));
+#endif
/* paren_pfx = ", "; */
}
if (acurrent != abase || abase != apeak || interesting_alimit)
Strcat(valubuf, ")");
}
+/*JP
enl_msg(subjbuf, "is ", "was ", valubuf, "");
+*/
+ enl_msg(subjbuf, "\82¾", "\82¾\82Á\82½", valubuf, "");
}
/* status: selected obvious capabilities, assorted troubles */
int final;
{
boolean magic = (mode & MAGICENLIGHTENMENT) ? TRUE : FALSE;
- int cap;
+ int cap, wtype;
char buf[BUFSZ], youtoo[BUFSZ];
boolean Riding = (u.usteed
/* if hero dies while dismounting, u.usteed will still
be set; we want to ignore steed in that situation */
&& !(final == ENL_GAMEOVERDEAD
+/*JP
&& !strcmp(killer.name, "riding accident")));
+*/
+ && !strcmp(killer.name, "\8bR\8fæ\8e\96\8cÌ\82Å")));
const char *steedname = (!Riding ? (char *) 0
: x_monnam(u.usteed,
u.usteed->mtame ? ARTICLE_YOUR : ARTICLE_THE,
* Status (many are abbreviated on bottom line; others are or
* should be discernible to the hero hence to the player)
\*/
- putstr(en_win, 0, ""); /* separator after title or characteristics */
- putstr(en_win, 0, final ? "Final Status:" : "Current Status:");
+ enlght_out(""); /* separator after title or characteristics */
+/*JP
+ enlght_out(final ? "Final Status:" : "Current Status:");
+*/
+ enlght_out(final ? "\8dÅ\8fI\8fó\91Ô:" : "\8c»\8dÝ\82Ì\8fó\91Ô:");
Strcpy(youtoo, You_);
/* not a traditional status but inherently obvious to player; more
detail given below (attributes section) for magic enlightenment */
- if (Upolyd)
- you_are("transformed", "");
+ if (Upolyd) {
+#if 0 /*JP*/
+ Strcpy(buf, "transformed");
+ if (ugenocided())
+ Sprintf(eos(buf), " and %s %s inside",
+ final ? "felt" : "feel", udeadinside());
+ you_are(buf, "");
+#else /*JP:TODO:\95Ï\89»+\8bs\8eE\83p\83^\81[\83\93*/
+ you_are_ing("\95Ï\89»\82µ\82Ä", "");
+#endif
+ }
/* not a trouble, but we want to display riding status before maybe
reporting steed as trapped or hero stuck to cursed saddle */
if (Riding) {
+#if 0 /*JP:T*/
Sprintf(buf, "riding %s", steedname);
you_are(buf, "");
+#else
+ Sprintf(buf, "%s\82É\8fæ\82Á\82Ä", steedname);
+ you_are_ing(buf, "");
+#endif
+/*JP
Sprintf(eos(youtoo), "and %s ", steedname);
+*/
+ Sprintf(youtoo, "\82 \82È\82½\82Æ%s\82Í", steedname);
}
/* other movement situations that hero should always know */
if (Levitation) {
if (Lev_at_will && magic)
+/*JP
you_are("levitating, at will", "");
+*/
+ you_are_ing("\8e©\95ª\82Ì\88Ó\8eu\82Å\95\82\97V\82µ\82Ä", "");
else
+/*JP
enl_msg(youtoo, are, were, "levitating", from_what(LEVITATION));
+*/
+ enl_msg(youtoo, "\82¢\82é", "\82¢\82½", "\95\82\97V\82µ\82Ä", from_what(LEVITATION));
} else if (Flying) { /* can only fly when not levitating */
+/*JP
enl_msg(youtoo, are, were, "flying", from_what(FLYING));
+*/
+ enl_msg(youtoo, "\82¢\82é", "\82¢\82½", "\94ò\82ñ\82Å", from_what(FLYING));
}
if (Underwater) {
+/*JP
you_are("underwater", "");
+*/
+ enl_msg(You_, "\82¢\82é", "\82¢\82½", "\90\85\96Ê\89º\82É", "");
} else if (u.uinwater) {
+/*JP
you_are(Swimming ? "swimming" : "in water", from_what(SWIMMING));
+*/
+ enl_msg(You_, Swimming ? "\89j\82¢\82Å" : "\90\85\92\86\82É", "\82¢\82é", "\82¢\82½", from_what(SWIMMING));
} else if (walking_on_water()) {
/* show active Wwalking here, potential Wwalking elsewhere */
+#if 0 /*JP*/
Sprintf(buf, "walking on %s",
is_pool(u.ux, u.uy) ? "water"
: is_lava(u.ux, u.uy) ? "lava"
: surface(u.ux, u.uy)); /* catchall; shouldn't happen */
you_are(buf, from_what(WWALKING));
+#else
+ Sprintf(buf, "%s\82Ì\8fã\82ð\95à\82¢\82Ä",
+ is_pool(u.ux, u.uy) ? "\90\85"
+ : is_lava(u.ux, u.uy) ? "\97n\8aâ"
+ : surface(u.ux, u.uy)); /* catchall; shouldn't happen */
+ you_are_ing(buf, from_what(WWALKING));
+#endif
}
- if (Upolyd && (u.uundetected || youmonst.m_ap_type != M_AP_NOTHING))
+ if (Upolyd && (u.uundetected || U_AP_TYPE != M_AP_NOTHING))
youhiding(TRUE, final);
/* internal troubles, mostly in the order that prayer ranks them */
- if (Stoned)
- you_are("turning to stone", "");
- if (Slimed)
- you_are("turning into slime", "");
+ if (Stoned) {
+ if (final && (Stoned & I_SPECIAL))
+/*JP
+ enlght_out(" You turned into stone.");
+*/
+ enlght_out(" \82 \82È\82½\82Í\90Î\82É\82È\82Á\82½\81D");
+ else
+/*JP
+ you_are("turning to stone", "");
+*/
+ enl_msg("\82 \82È\82½\82Í", "\82È\82è\82Â\82Â\82 \82é", "\82È\82Á\82½", "\90Î\82É", "");
+ }
+ if (Slimed) {
+ if (final && (Slimed & I_SPECIAL))
+/*JP
+ enlght_out(" You turned into slime.");
+*/
+ enlght_out(" \82 \82È\82½\82Í\83X\83\89\83C\83\80\82É\82È\82Á\82½\81D");
+ else
+/*JP
+ you_are("turning into slime", "");
+*/
+ enl_msg("\82 \82È\82½\82Í", "\82È\82è\82Â\82Â\82 \82é", "\82È\82Á\82½", "\83X\83\89\83C\83\80\82É", "");
+ }
if (Strangled) {
if (u.uburied) {
+/*JP
you_are("buried", "");
+*/
+ you_are_ing("\92\82\91§\82µ\82Ä", "");
} else {
- Strcpy(buf, "being strangled");
- if (wizard)
- Sprintf(eos(buf), " (%ld)", (Strangled & TIMEOUT));
- you_are(buf, from_what(STRANGLED));
+ if (final && (Strangled & I_SPECIAL)) {
+/*JP
+ enlght_out(" You died from strangulation.");
+*/
+ enlght_out(" \82 \82È\82½\82Í\92\82\91§\8e\80\82µ\82½\81D");
+ } else {
+/*JP
+ Strcpy(buf, "being strangled");
+*/
+ Strcpy(buf, "\8eñ\82ð\8di\82ß\82ç\82ê\82Ä");
+ if (wizard)
+ Sprintf(eos(buf), " (%ld)", (Strangled & TIMEOUT));
+/*JP
+ you_are(buf, from_what(STRANGLED));
+*/
+ enl_msg("\82 \82È\82½\82Í", "\82¢\82é", "\82¢\82½", buf, from_what(STRANGLED));
+ }
}
}
if (Sick) {
- /* prayer lumps these together; botl puts Ill before FoodPois */
- if (u.usick_type & SICK_NONVOMITABLE)
- you_are("terminally sick from illness", "");
- if (u.usick_type & SICK_VOMITABLE)
- you_are("terminally sick from food poisoning", "");
+ /* the two types of sickness are lumped together; hero can be
+ afflicted by both but there is only one timeout; botl status
+ puts TermIll before FoodPois and death due to timeout reports
+ terminal illness if both are in effect, so do the same here */
+ if (final && (Sick & I_SPECIAL)) {
+#if 0 /*JP:T*/
+ Sprintf(buf, " %sdied from %s.", You_, /* has trailing space */
+ (u.usick_type & SICK_NONVOMITABLE)
+ ? "terminal illness" : "food poisoning");
+#else
+ Sprintf(buf, " %s%s\82Å\8e\80\82ñ\82¾\81D", You_, /* has trailing space */
+ (u.usick_type & SICK_NONVOMITABLE)
+ ? "\95a\8bC" : "\90H\92\86\93Å");
+#endif
+ enlght_out(buf);
+ } else {
+ /* unlike death due to sickness, report the two cases separately
+ because it is possible to cure one without curing the other */
+ if (u.usick_type & SICK_NONVOMITABLE)
+/*JP
+ you_are("terminally sick from illness", "");
+*/
+ enl_msg("\82 \82È\82½\82Í\95a\8bC\82Å\92v\96½\93I\82É\8bC\95ª\82ª\88«", "\82¢", "\82©\82Á\82½", "", "");
+ if (u.usick_type & SICK_VOMITABLE)
+/*JP
+ you_are("terminally sick from food poisoning", "");
+*/
+ enl_msg("\82 \82È\82½\82Í\90H\92\86\93Å\82Å\92v\96½\93I\82É\8bC\95ª\82ª\88«", "\82¢", "\82©\82Á\82½", "", "");
+ }
}
if (Vomiting)
+/*JP
you_are("nauseated", "");
+*/
+ enl_msg(You_, "\93f\82«\8bC\82ª", "\82 \82é", "\82 \82Á\82½", "");
if (Stunned)
+/*JP
you_are("stunned", "");
+*/
+ you_are("\82\82ç\82\82ç\8fó\91Ô", "");
if (Confusion)
+/*JP
you_are("confused", "");
+*/
+ you_are("\8d¬\97\90\8fó\91Ô", "");
if (Hallucination)
+/*JP
you_are("hallucinating", "");
+*/
+ you_are("\8c¶\8ao\8fó\91Ô", "");
if (Blind) {
/* from_what() (currently wizard-mode only) checks !haseyes()
before u.uroleplay.blind, so we should too */
+#if 0 /*JP:T*/
Sprintf(buf, "%s blind",
!haseyes(youmonst.data) ? "innately"
: u.uroleplay.blind ? "permanently"
/* better phrasing desperately wanted... */
: Blindfolded_only ? "deliberately"
: "temporarily");
+#else
+ Sprintf(buf, "%s\96Ó\96Ú",
+ !haseyes(youmonst.data) ? "\90¶\82Ü\82ê\82È\82ª\82ç\82É"
+ : u.uroleplay.blind ? "\8dP\8bv\93I\82É"
+ /* better phrasing desperately wanted... */
+ : Blindfolded_only ? "\8cÌ\88Ó\82É"
+ : "\88ê\8e\9e\93I\82É");
+#endif
if (wizard && (Blinded & TIMEOUT) != 0L
&& !u.uroleplay.blind && haseyes(youmonst.data))
Sprintf(eos(buf), " (%ld)", (Blinded & TIMEOUT));
you_are(buf, !haseyes(youmonst.data) ? "" : from_what(BLINDED));
}
if (Deaf)
+/*JP
you_are("deaf", from_what(DEAF));
+*/
+ you_are("\8e¨\82ª\95·\82±\82¦\82È\82¢\8fó\91Ô", from_what(DEAF));
/* external troubles, more or less */
if (Punished) {
if (uball) {
+/*JP
Sprintf(buf, "chained to %s", ansimpleoname(uball));
+*/
+ Sprintf(buf, "%s\82É\82Â\82È\82ª\82ê\82Ä", ansimpleoname(uball));
} else {
impossible("Punished without uball?");
+/*JP
Strcpy(buf, "punished");
+*/
+ Strcpy(buf, "\94±\82ð\8eó\82¯\82Ä");
}
you_are(buf, "");
}
boolean anchored = (u.utraptype == TT_BURIEDBALL);
if (anchored) {
+/*JP
Strcpy(predicament, "tethered to something buried");
+*/
+ Strcpy(predicament, "\89½\82©\96\84\82Ü\82Á\82Ä\82¢\82é\82à\82Ì\82É\82Â\82È\82ª\82ê\82Ä");
} else if (u.utraptype == TT_INFLOOR || u.utraptype == TT_LAVA) {
+/*JP
Sprintf(predicament, "stuck in %s", the(surface(u.ux, u.uy)));
+*/
+ Sprintf(predicament, "%s\82É\96\84\82Ü\82Á\82Ä", surface(u.ux, u.uy));
} else {
+#if 0 /*JP*/
Strcpy(predicament, "trapped");
if ((t = t_at(u.ux, u.uy)) != 0)
Sprintf(eos(predicament), " in %s",
an(defsyms[trap_to_defsym(t->ttyp)].explanation));
+#else
+ predicament[0] = '\0';
+ if ((t = t_at(u.ux, u.uy)) != 0)
+ Sprintf(predicament, "%s\82É",
+ defsyms[trap_to_defsym(t->ttyp)].explanation);
+ Strcat(predicament, "\82Ð\82Á\82©\82©\82Á\82Ä");
+#endif
}
if (u.usteed) { /* not `Riding' here */
+#if 0 /*JP*/
Sprintf(buf, "%s%s ", anchored ? "you and " : "", steedname);
*buf = highc(*buf);
enl_msg(buf, (anchored ? "are " : "is "),
(anchored ? "were " : "was "), predicament, "");
+#else
+ Sprintf(buf, "%s%s\82Í", anchored ? "\82 \82È\82½\82Æ" : "", steedname);
+ enl_msg(buf, "\82¢\82é", "\82¢\82½" , predicament, "");
+#endif
} else
you_are(predicament, "");
} /* (u.utrap) */
if (u.uswallow) {
+/*JP
Sprintf(buf, "swallowed by %s", a_monnam(u.ustuck));
+*/
+ Sprintf(buf, "%s\82É\88ù\82Ý\8d\9e\82Ü\82ê\82Ä", a_monnam(u.ustuck));
if (wizard)
Sprintf(eos(buf), " (%u)", u.uswldtim);
you_are(buf, "");
} else if (u.ustuck) {
+#if 0 /*JP*/
Sprintf(buf, "%s %s",
(Upolyd && sticks(youmonst.data)) ? "holding" : "held by",
a_monnam(u.ustuck));
you_are(buf, "");
+#else
+ Sprintf(buf, "%s%s",
+ a_monnam(u.ustuck),
+ (Upolyd && sticks(youmonst.data)) ? "\82ð\95ß\82Ü\82¦\82Ä" : "\82É\95ß\82Ü\82Á\82Ä");
+ you_are_ing(buf, "");
+#endif
}
if (Riding) {
struct obj *saddle = which_armor(u.usteed, W_SADDLE);
if (saddle && saddle->cursed) {
+#if 0 /*JP*/
Sprintf(buf, "stuck to %s %s", s_suffix(steedname),
simpleonames(saddle));
you_are(buf, "");
+#else
+ Sprintf(buf, "%s\82Ì%s\82É\82Â\82©\82Ü\82Á\82Ä", steedname,
+ simpleonames(saddle));
+ you_are_ing(buf, "");
+#endif
}
}
if (Wounded_legs) {
hero; we only report steed's wounded legs in wizard mode */
if (u.usteed) { /* not `Riding' here */
if (wizard && steedname) {
+#if 0 /*JP*/
Strcpy(buf, steedname);
*buf = highc(*buf);
enl_msg(buf, " has", " had", " wounded legs", "");
- }
+#else
+ enl_msg(buf, iru, ita, "\82Í\8e\88\82ð\89ö\89ä\82µ\82Ä", "");
+#endif
+ }
} else {
+#if 0 /*JP*/
Sprintf(buf, "wounded %s", makeplural(body_part(LEG)));
you_have(buf, "");
+#else
+ Sprintf(buf, "%s\82ð\89ö\89ä\82µ\82Ä", makeplural(body_part(LEG)));
+ you_are_ing(buf, "");
+#endif
}
}
if (Glib) {
- Sprintf(buf, "slippery %s", makeplural(body_part(FINGER)));
+#if 0 /*JP*/
+ Sprintf(buf, "slippery %s", fingers_or_gloves(TRUE));
+ if (wizard)
+ Sprintf(eos(buf), " (%ld)", (Glib & TIMEOUT));
you_have(buf, "");
+#else
+ Sprintf(buf, "%s\82ª\82Ê\82é\82Ê\82é\82µ\82Ä", body_part(FINGER));
+ if (wizard)
+ Sprintf(eos(buf), " (%ld)", (Glib & TIMEOUT));
+ enl_msg(buf, iru, ita, "", "");
+#endif
}
if (Fumbling) {
if (magic || cause_known(FUMBLING))
+/*JP
enl_msg(You_, "fumble", "fumbled", "", from_what(FUMBLING));
+*/
+ you_are_ing("\95s\8aí\97p\82É\82È\82Á\82Ä", from_what(FUMBLING));
}
if (Sleepy) {
if (magic || cause_known(SLEEPY)) {
Strcpy(buf, from_what(SLEEPY));
if (wizard)
Sprintf(eos(buf), " (%ld)", (HSleepy & TIMEOUT));
+/*JP
enl_msg("You ", "fall", "fell", " asleep uncontrollably", buf);
+*/
+ you_are_ing("\96°\82Á\82Ä", buf);
}
}
/* hunger/nutrition */
if (Hunger) {
if (magic || cause_known(HUNGER))
+#if 0 /*JP*/
enl_msg(You_, "hunger", "hungered", " rapidly",
from_what(HUNGER));
+#else
+ enl_msg("\82 \82È\82½\82Í\82·\82®\82É\95 \82ª\8c¸\82é\8fó\91Ô", "\82Å\82 \82é", "\82¾\82Á\82½", "", "");
+#endif
}
Strcpy(buf, hu_stat[u.uhs]); /* hunger status; omitted if "normal" */
mungspaces(buf); /* strip trailing spaces */
if (*buf) {
+#if 0 /*JP*/
*buf = lowc(*buf); /* override capitalization */
if (!strcmp(buf, "weak"))
Strcat(buf, " from severe hunger");
else if (!strncmp(buf, "faint", 5)) /* fainting, fainted */
Strcat(buf, " due to starvation");
you_are(buf, "");
+#else
+ Strcat(buf, "\8fó\91Ô");
+ you_are(buf, "");
+#endif
}
/* encumbrance */
if ((cap = near_capacity()) > UNENCUMBERED) {
+#if 0 /*JP*/
const char *adj = "?_?"; /* (should always get overridden) */
Strcpy(buf, enc_stat[cap]);
Sprintf(eos(buf), "; movement %s %s%s", !final ? "is" : "was", adj,
(cap < OVERLOADED) ? " slowed" : "");
you_are(buf, "");
+#else
+ Sprintf(buf, "\89×\95¨\82É\82æ\82Á\82Ä%s\8fó\91Ô", enc_stat[cap]);
+ you_are(buf, "");
+#endif
} else {
/* last resort entry, guarantees Status section is non-empty
(no longer needed for that purpose since weapon status added;
still useful though) */
+/*JP
you_are("unencumbered", "");
+*/
+ you_are("\89×\95¨\82Í\8e×\96\82\82É\82È\82ç\82È\82¢\8fó\91Ô", "");
}
+
/* report being weaponless; distinguish whether gloves are worn */
if (!uwep) {
+#if 0 /*JP*/
you_are(uarmg ? "empty handed" /* gloves imply hands */
: humanoid(youmonst.data)
/* hands but no weapon and no gloves */
/* alternate phrasing for paws or lack of hands */
: "not wielding anything",
"");
- /* two-weaponing implies a weapon (not other odd stuff) in each hand */
+#else
+ enl_msg(You_, "\82¢", "\82©\82Á\82½", "\95\90\8aí\82ð\91\95\94õ\82µ\82Ä\82¢\82È", "");
+#endif
+ /* two-weaponing implies hands (can't be polymorphed) and
+ a weapon or wep-tool (not other odd stuff) in each hand */
} else if (u.twoweap) {
+/*JP
you_are("wielding two weapons at once", "");
+*/
+ you_are("\93ñ\93\81\97¬", "");
/* report most weapons by their skill class (so a katana will be
described as a long sword, for instance; mattock and hook are
exceptions), or wielded non-weapon item by its object class */
} else {
const char *what = weapon_descr(uwep);
+#if 0 /*JP*/
if (!strcmpi(what, "armor") || !strcmpi(what, "food")
|| !strcmpi(what, "venom"))
Sprintf(buf, "wielding some %s", what);
Sprintf(buf, "wielding %s",
(uwep->quan == 1L) ? an(what) : makeplural(what));
you_are(buf, "");
+#else
+ Sprintf(buf, "%s\82ð\91\95\94õ\82µ\82Ä", what);
+ enl_msg(You_, "\82¢\82é", "\82¢\82½", buf, "");
+#endif
+ }
+ /*
+ * Skill with current weapon. Might help players who've never
+ * noticed #enhance or decided that it was pointless.
+ *
+ * TODO? Maybe merge wielding line and skill line into one sentence.
+ */
+ if ((wtype = uwep_skill_type()) != P_NONE) {
+ char sklvlbuf[20];
+ int sklvl = P_SKILL(wtype);
+ boolean hav = (sklvl != P_UNSKILLED && sklvl != P_SKILLED);
+
+ if (sklvl == P_ISRESTRICTED)
+/*JP
+ Strcpy(sklvlbuf, "no");
+*/
+ Strcpy(sklvlbuf, "\90§\8cÀ");
+ else
+ (void) lcase(skill_level_name(wtype, sklvlbuf));
+ /* "you have no/basic/expert/master/grand-master skill with <skill>"
+ or "you are unskilled/skilled in <skill>" */
+#if 0 /*JP:T*/
+ Sprintf(buf, "%s %s %s", sklvlbuf,
+ hav ? "skill with" : "in", skill_name(wtype));
+#else
+ Sprintf(buf, "%s\82Ì%s\83X\83L\83\8b", skill_name(wtype), sklvlbuf);
+#endif
+ if (can_advance(wtype, FALSE))
+#if 0 /*JP:T*/
+ Sprintf(eos(buf), " and %s that",
+ !final ? "can enhance" : "could have enhanced");
+#else
+ Sprintf(eos(buf), "(\8d\82\82ß\82é\82±\82Æ\82ª\82Å\82«%s)",
+ !final ? "\82é" : "\82½");
+#endif
+ if (hav)
+ you_have(buf, "");
+ else
+ you_are(buf, "");
}
/* report 'nudity' */
- if (!uarm && !uarmu && !uarmc && !uarmg && !uarmf && !uarmh) {
+ if (!uarm && !uarmu && !uarmc && !uarms && !uarmg && !uarmf && !uarmh) {
if (u.uroleplay.nudist)
+#if 0 /*JP:T*/
enl_msg(You_, "do", "did", " not wear any armor", "");
+#else
+ enl_msg(You_, "\82¢", "\82©\82Á\82½", "\89½\82Ì\8aZ\82à\91\95\94õ\82µ\82È", "");
+#endif
else
+#if 0 /*JP:T*/
you_are("not wearing any armor", "");
+#else
+ enl_msg(You_, "\82¢", "\82©\82Á\82½", "\89½\82Ì\8aZ\82à\91\95\94õ\82µ\82Ä\82¢\82È", "");
+#endif
}
}
/* attributes: intrinsics and the like, other non-obvious capabilities */
-void
+STATIC_OVL void
attributes_enlightenment(unused_mode, final)
int unused_mode UNUSED;
int final;
{
+#if 0 /*JP*/
static NEARDATA const char if_surroundings_permitted[] =
" if surroundings permitted";
+#endif
int ltmp, armpro;
char buf[BUFSZ];
/*\
* Attributes
\*/
- putstr(en_win, 0, "");
- putstr(en_win, 0, final ? "Final Attributes:" : "Current Attributes:");
+ enlght_out("");
+/*JP
+ enlght_out(final ? "Final Attributes:" : "Current Attributes:");
+*/
+ enlght_out(final ? "\8dÅ\8fI\91®\90«:" : "\8c»\8dÝ\82Ì\91®\90«:");
if (u.uevent.uhand_of_elbereth) {
-#if 0 /*JP*/
+#if 0 /*JP:T*/
static const char *const hofe_titles[3] = { "the Hand of Elbereth",
"the Envoy of Balance",
"the Glory of Arioch" };
you_are(hofe_titles[u.uevent.uhand_of_elbereth - 1], "");
}
- /* note: piousness 20 matches MIN_QUEST_ALIGN (quest.h) */
- if (u.ualign.record >= 20)
-/*JP
- you_are("piously aligned", "");
-*/
- you_have("\8chåi\82È\90M\8bÂ\90S", "");
- else if (u.ualign.record > 13)
/*JP
- you_are("devoutly aligned", "");
+ Sprintf(buf, "%s", piousness(TRUE, "aligned"));
*/
- you_have("\90S\82©\82ç\82Ì\90M\8bÂ\90S", "");
- else if (u.ualign.record > 8)
-/*JP
- you_are("fervently aligned", "");
-*/
- you_have("\94M\90S\82È\90M\8bÂ\90S", "");
- else if (u.ualign.record > 3)
-/*JP
- you_are("stridently aligned", "");
-*/
- you_have("\82¨\82¨\82°\82³\82È\90M\8bÂ\90S", "");
- else if (u.ualign.record == 3)
-/*JP
- you_are("aligned", "");
-*/
- you_have("\95\81\92Ê\82Ì\90M\8bÂ\90S", "");
- else if (u.ualign.record > 0)
-/*JP
- you_are("haltingly aligned", "");
-*/
- you_have("çSçO\82µ\82È\82ª\82ç\82à\90M\8bÂ\90S", "");
- else if (u.ualign.record == 0)
-/*JP
- you_are("nominally aligned", "");
-*/
- you_have("\8c`\82¾\82¯\82Ì\90M\8bÂ\90S", "");
- else if (u.ualign.record >= -3)
-/*JP
- you_have("strayed", "");
-*/
- you_are_ing("\90M\8bÂ\82É\96À\82¢\82ð\82à\82Á\82Ä");
- else if (u.ualign.record >= -8)
-/*JP
- you_have("sinned", "");
-*/
- you_are_ing("\8dß\82ð\95\89\82Á\82Ä");
+ Sprintf(buf, "%s", piousness(TRUE, "\90M\8bÂ\90S"));
+ if (u.ualign.record >= 0)
+ you_are(buf, "");
else
-/*JP
- you_have("transgressed", "");
-*/
- you_are_ing("\90M\8bÂ\82©\82ç\88í\92E\82µ\82Ä");
+ you_have(buf, "");
+
if (wizard) {
-#if 0 /*JP*/
+#if 0 /*JP:T*/
Sprintf(buf, " %d", u.ualign.record);
enl_msg("Your alignment ", "is", "was", buf, "");
#else
/*** Resistances to troubles ***/
if (Invulnerable)
+/*JP
you_are("invulnerable", from_what(INVULNERABLE));
+*/
+ you_are("\95s\8e\80\90g", from_what(INVULNERABLE));
if (Antimagic)
+/*JP
you_are("magic-protected", from_what(ANTIMAGIC));
+*/
+ you_have("\96\82\96@\96h\8cä\94\\97Í", from_what(ANTIMAGIC));
if (Fire_resistance)
+/*JP
you_are("fire resistant", from_what(FIRE_RES));
+*/
+ you_have("\89Î\82Ö\82Ì\91Ï\90«", from_what(FIRE_RES));
if (Cold_resistance)
+/*JP
you_are("cold resistant", from_what(COLD_RES));
+*/
+ you_have("\8a¦\82³\82Ö\82Ì\91Ï\90«", from_what(COLD_RES));
if (Sleep_resistance)
+/*JP
you_are("sleep resistant", from_what(SLEEP_RES));
+*/
+ you_have("\96°\82è\82Ö\82Ì\91Ï\90«", from_what(SLEEP_RES));
if (Disint_resistance)
+/*JP
you_are("disintegration-resistant", from_what(DISINT_RES));
+*/
+ you_have("\95²\8dÓ\82Ö\82Ì\91Ï\90«", from_what(DISINT_RES));
if (Shock_resistance)
+/*JP
you_are("shock resistant", from_what(SHOCK_RES));
+*/
+ you_have("\93d\8c\82\82Ö\82Ì\91Ï\90«", from_what(SHOCK_RES));
if (Poison_resistance)
+/*JP
you_are("poison resistant", from_what(POISON_RES));
+*/
+ you_have("\93Å\82Ö\82Ì\91Ï\90«", from_what(POISON_RES));
if (Acid_resistance)
+/*JP
you_are("acid resistant", from_what(ACID_RES));
+*/
+ you_have("\8e_\82Ö\82Ì\91Ï\90«", from_what(ACID_RES));
if (Drain_resistance)
+/*JP
you_are("level-drain resistant", from_what(DRAIN_RES));
+*/
+ you_have("\83\8c\83x\83\8b\83_\83E\83\93\82Ö\82Ì\91Ï\90«", from_what(DRAIN_RES));
if (Sick_resistance)
+/*JP
you_are("immune to sickness", from_what(SICK_RES));
+*/
+ you_have("\95a\8bC\82É\91Î\82·\82é\96Æ\89u", from_what(SICK_RES));
if (Stone_resistance)
+/*JP
you_are("petrification resistant", from_what(STONE_RES));
+*/
+ you_have("\90Î\89»\82Ö\82Ì\91Ï\90«", from_what(STONE_RES));
if (Halluc_resistance)
+#if 0 /*JP:T*/
enl_msg(You_, "resist", "resisted", " hallucinations",
from_what(HALLUC_RES));
+#else
+ you_have("\8c¶\8ao\82Ö\82Ì\91Ï\90«", from_what(HALLUC_RES));
+#endif
if (u.uedibility)
+/*JP
you_can("recognize detrimental food", "");
+*/
+ you_can("\97L\8aQ\82È\90H\97¿\82ð\8e¯\95Ê", "");
/*** Vision and senses ***/
if (!Blind && (Blinded || !haseyes(youmonst.data)))
+#if 0 /*JP*/
you_can("see", from_what(-BLINDED)); /* Eyes of the Overworld */
+#else /*\81u\92´\90¢\8aE\82Ì\96Ú\82É\82æ\82Á\82Ä\8c©\82é\82±\82Æ\82ª\82Å\82«\82é\81v*/
+ you_can("\8c©\82é\82±\82Æ\82ª", from_what(-BLINDED)); /* Eyes of the Overworld */
+#endif
if (See_invisible) {
if (!Blind)
+/*JP
enl_msg(You_, "see", "saw", " invisible", from_what(SEE_INVIS));
+*/
+ enl_msg("\82 \82È\82½\82Í\93§\96¾\82È\82à\82Ì\82ð\8c©\82ç\82ê", "\82é", "\82½", "", from_what(SEE_INVIS));
else
+#if 0 /*JP:T*/
enl_msg(You_, "will see", "would have seen",
" invisible when not blind", from_what(SEE_INVIS));
+#else
+ enl_msg(You_, "\82é", "\82½",
+ "\96Ó\96Ú\82Å\82È\82¢\82Æ\82«\82É\82Í\93§\96¾\82È\82à\82Ì\82ð\8c©\82ç\82ê", from_what(SEE_INVIS));
+#endif
}
if (Blind_telepat)
+/*JP
you_are("telepathic", from_what(TELEPAT));
+*/
+ you_have("\83e\83\8c\83p\83V\81[", from_what(TELEPAT));
if (Warning)
+/*JP
you_are("warned", from_what(WARNING));
+*/
+ you_have("\8cx\89ú\94\\97Í", from_what(WARNING));
if (Warn_of_mon && context.warntype.obj) {
+#if 0 /*JP:T*/
Sprintf(buf, "aware of the presence of %s",
(context.warntype.obj & M2_ORC) ? "orcs"
: (context.warntype.obj & M2_ELF) ? "elves"
: (context.warntype.obj & M2_DEMON) ? "demons" : something);
you_are(buf, from_what(WARN_OF_MON));
+#else
+ Sprintf(buf, "%s\82Ì\91¶\8dÝ\82ð\8a´\82¶\82é\94\\97Í",
+ (context.warntype.obj & M2_ORC) ? "\83I\81[\83N"
+ : (context.warntype.obj & M2_ELF) ? "\83G\83\8b\83t"
+ : (context.warntype.obj & M2_DEMON) ? "\88«\96\82" : something);
+ you_have(buf, "");
+#endif
}
if (Warn_of_mon && context.warntype.polyd) {
+#if 0 /*JP*/
Sprintf(buf, "aware of the presence of %s",
((context.warntype.polyd & (M2_HUMAN | M2_ELF))
== (M2_HUMAN | M2_ELF))
? "demons"
: "certain monsters");
you_are(buf, "");
+#else
+ Sprintf(buf, "%s\82Ì\91¶\8dÝ\82ð\8a´\82¶\82é\94\\97Í",
+ ((context.warntype.polyd & (M2_HUMAN | M2_ELF))
+ == (M2_HUMAN | M2_ELF))
+ ? "\90l\8aÔ\82Æ\83G\83\8b\83t"
+ : (context.warntype.polyd & M2_HUMAN)
+ ? "\90l\8aÔ"
+ : (context.warntype.polyd & M2_ELF)
+ ? "\83G\83\8b\83t"
+ : (context.warntype.polyd & M2_ORC)
+ ? "\83I\81[\83N"
+ : (context.warntype.polyd & M2_DEMON)
+ ? "\88«\96\82"
+ : "\82 \82é\8eí\82Ì\89ö\95¨");
+ you_have(buf, "");
+#endif
}
- if (Warn_of_mon && context.warntype.speciesidx) {
+ if (Warn_of_mon && context.warntype.speciesidx >= LOW_PM) {
+#if 0 /*JP*/
Sprintf(buf, "aware of the presence of %s",
makeplural(mons[context.warntype.speciesidx].mname));
you_are(buf, from_what(WARN_OF_MON));
+#else
+ Sprintf(buf, "%s\82Ì\91¶\8dÝ\82ð\8a´\82¶\82é\94\\97Í",
+ mons[context.warntype.speciesidx].mname);
+ you_have(buf, from_what(WARN_OF_MON));
+#endif
}
if (Undead_warning)
+/*JP
you_are("warned of undead", from_what(WARN_UNDEAD));
+*/
+ you_have("\95s\8e\80\82Ì\90¶\95¨\82Ö\82Ì\8cx\89ú\94\\97Í", from_what(WARN_UNDEAD));
if (Searching)
+/*JP
you_have("automatic searching", from_what(SEARCHING));
+*/
+ you_have("\92T\8d¸\94\\97Í", from_what(SEARCHING));
if (Clairvoyant)
+/*JP
you_are("clairvoyant", from_what(CLAIRVOYANT));
+*/
+ you_have("\90ç\97¢\8aá\94\\97Í", from_what(CLAIRVOYANT));
else if ((HClairvoyant || EClairvoyant) && BClairvoyant) {
Strcpy(buf, from_what(-CLAIRVOYANT));
+#if 0 /*JP*/
if (!strncmp(buf, " because of ", 12))
/* overwrite substring; strncpy doesn't add terminator */
(void) strncpy(buf, " if not for ", 12);
enl_msg(You_, "could be", "could have been", " clairvoyant", buf);
+#else
+ /*JP:\81u\81c\82É\82æ\82Á\82Ä\81v*/
+ if (!STRNCMP2(buf, "\82É\82æ\82Á\82Ä"))
+ /*JP:\81u\81c\82ª\82È\82¯\82ê\82Î\81v\82É\8f\91\82«\8a·\82¦\82é*/
+ strcpy(eos(buf) - strlen("\82É\82æ\82Á\82Ä"), "\82ª\82È\82¯\82ê\82Î");
+ you_have("\90ç\97¢\8aá\94\\97Í", buf);
+#endif
}
if (Infravision)
+/*JP
you_have("infravision", from_what(INFRAVISION));
+*/
+ you_have("\90Ô\8aO\90ü\82ª\8c©\82¦\82é\8e\8b\8ao", from_what(INFRAVISION));
if (Detect_monsters)
+/*JP
you_are("sensing the presence of monsters", "");
+*/
+ you_have("\89ö\95¨\82ð\92T\82·\94\\97Í", "");
if (u.umconf)
+/*JP
you_are("going to confuse monsters", "");
+*/
+ you_have("\89ö\95¨\82ð\8d¬\97\90\82³\82¹\82é\94\\97Í", "");
/*** Appearance and behavior ***/
if (Adornment) {
/* the sum might be 0 (+0 ring or two which negate each other);
that yields "you are charismatic" (which isn't pointless
because it potentially impacts seduction attacks) */
+#if 0 /*JP*/
Sprintf(buf, "%scharismatic",
(adorn > 0) ? "more " : (adorn < 0) ? "less " : "");
you_are(buf, from_what(ADORNED));
+#else
+ Sprintf(buf, "\96£\97Í%s\82Ä",
+ (adorn > 0) ? "\82ª\91\9d\89Á\82µ" : (adorn < 0) ? "\82ª\8c¸\8f\82µ" : "\93I\82É\82È\82Á");
+ enl_msg(You_, "\82Ä\82¢\82é", "\82½", buf, "");
+#endif
}
if (Invisible)
+/*JP
you_are("invisible", from_what(INVIS));
+*/
+ you_are("\93§\96¾", from_what(INVIS));
else if (Invis)
+/*JP
you_are("invisible to others", from_what(INVIS));
+*/
+ you_are("\91¼\90l\82É\91Î\82µ\82Ä\93§\96¾", from_what(INVIS));
/* ordinarily "visible" is redundant; this is a special case for
the situation when invisibility would be an expected attribute */
else if ((HInvis || EInvis) && BInvis)
+/*JP
you_are("visible", from_what(-INVIS));
+*/
+ you_are("\95s\93§\96¾", from_what(-INVIS));
if (Displaced)
+/*JP
you_are("displaced", from_what(DISPLACED));
+*/
+ you_have("\8c¶\89e\94\\97Í", from_what(DISPLACED));
if (Stealth)
+/*JP
you_are("stealthy", from_what(STEALTH));
+*/
+ you_have("\90l\96Ú\82ð\93\90\82Þ\94\\97Í", from_what(STEALTH));
if (Aggravate_monster)
+#if 0 /*JP*/
enl_msg("You aggravate", "", "d", " monsters",
from_what(AGGRAVATE_MONSTER));
+#else
+ you_are_ing("\94½\8a´\82ð\82©\82Á\82Ä", from_what(AGGRAVATE_MONSTER));
+#endif
if (Conflict)
+/*JP
enl_msg("You cause", "", "d", " conflict", from_what(CONFLICT));
+*/
+ you_are_ing("\93¬\91\88\82ð\88ø\82«\8bN\82±\82µ\82Ä", from_what(CONFLICT));
/*** Transportation ***/
if (Jumping)
+/*JP
you_can("jump", from_what(JUMPING));
+*/
+ you_can("\92µ\96ô\82·\82é\82±\82Æ\82ª", from_what(JUMPING));
if (Teleportation)
+/*JP
you_can("teleport", from_what(TELEPORT));
+*/
+ you_can("\8fu\8aÔ\88Ú\93®\82ª", from_what(TELEPORT));
if (Teleport_control)
+/*JP
you_have("teleport control", from_what(TELEPORT_CONTROL));
+*/
+ you_have("\8fu\8aÔ\88Ú\93®\82Ì\90§\8cä\94\\97Í", from_what(TELEPORT_CONTROL));
/* actively levitating handled earlier as a status condition */
if (BLevitation) { /* levitation is blocked */
long save_BLev = BLevitation;
BLevitation = 0L;
- if (Levitation)
- enl_msg(You_, "would levitate", "would have levitated",
- if_surroundings_permitted, "");
+ if (Levitation) {
+ /* either trapped in the floor or inside solid rock
+ (or both if chained to buried iron ball and have
+ moved one step into solid rock somehow) */
+#if 0 /*JP*/
+ boolean trapped = (save_BLev & I_SPECIAL) != 0L,
+ terrain = (save_BLev & FROMOUTSIDE) != 0L;
+
+ Sprintf(buf, "%s%s%s",
+ trapped ? " if not trapped" : "",
+ (trapped && terrain) ? " and" : "",
+ terrain ? if_surroundings_permitted : "");
+ enl_msg(You_, "would levitate", "would have levitated", buf, "");
+#else
+ you_are("\8fó\8bµ\82ª\8b\96\82¹\82Î\95\82\97V\82·\82é\8fó\91Ô", "");
+#endif
+ }
BLevitation = save_BLev;
}
/* actively flying handled earlier as a status condition */
long save_BFly = BFlying;
BFlying = 0L;
- if (Flying)
+ if (Flying) {
+#if 0 /*JP:T*/
enl_msg(You_, "would fly", "would have flown",
+ /* wording quibble: for past tense, "hadn't been"
+ would sound better than "weren't" (and
+ "had permitted" better than "permitted"), but
+ "weren't" and "permitted" are adequate so the
+ extra complexity to handle that isn't worth it */
+ Levitation
+ ? " if you weren't levitating"
+ : (save_BFly == I_SPECIAL)
+ /* this is an oversimpliction; being trapped
+ might also be blocking levitation so flight
+ would still be blocked after escaping trap */
+ ? " if you weren't trapped"
+ : (save_BFly == FROMOUTSIDE)
+ ? if_surroundings_permitted
+ /* two or more of levitation, surroundings,
+ and being trapped in the floor */
+ : " if circumstances permitted",
+ "");
+#else
+ enl_msg(You_, "\94ò\82Ô\82±\82Æ\82ª\82Å\82«\82é", "\94ò\82Ô\82±\82Æ\82ª\82Å\82«\82½",
+ /* wording quibble: for past tense, "hadn't been"
+ would sound better than "weren't" (and
+ "had permitted" better than "permitted"), but
+ "weren't" and "permitted" are adequate so the
+ extra complexity to handle that isn't worth it */
Levitation
- ? "if you weren't levitating"
- : (save_BFly == FROMOUTSIDE)
- ? if_surroundings_permitted
- /* both surroundings and [latent] levitation */
- : " if circumstances permitted",
+ ? "\95\82\97V\82µ\82Ä\82¢\82È\82¯\82ê\82Î"
+ : (save_BFly == I_SPECIAL)
+ /* this is an oversimpliction; being trapped
+ might also be blocking levitation so flight
+ would still be blocked after escaping trap */
+ ? "\95ß\82Ü\82Á\82Ä\82¢\82È\82¯\82ê\82Î"
+ : (save_BFly == FROMOUTSIDE)
+ ? "\8fó\8bµ\82ª\8b\96\82¹\82Î"
+ /* two or more of levitation, surroundings,
+ and being trapped in the floor */
+ : "\8e\96\8fî\82ª\8b\96\82¹\82Î",
"");
+#endif
+ }
BFlying = save_BFly;
}
/* actively walking on water handled earlier as a status condition */
if (Wwalking && !walking_on_water())
+/*JP
you_can("walk on water", from_what(WWALKING));
+*/
+ you_can("\90\85\82Ì\8fã\82ð\95à\82\82±\82Æ\82ª", from_what(WWALKING));
/* actively swimming (in water but not under it) handled earlier */
if (Swimming && (Underwater || !u.uinwater))
+/*JP
you_can("swim", from_what(SWIMMING));
+*/
+ you_can("\89j\82®\82±\82Æ\82ª", from_what(SWIMMING));
if (Breathless)
+/*JP
you_can("survive without air", from_what(MAGICAL_BREATHING));
+*/
+ you_can("\8bó\8bC\82È\82µ\82Å\90¶\82«\89\84\82Ñ\82é\82±\82Æ\82ª", from_what(MAGICAL_BREATHING));
else if (Amphibious)
+/*JP
you_can("breathe water", from_what(MAGICAL_BREATHING));
+*/
+ you_can("\90\85\92\86\82Å\8cÄ\8bz\82ª", from_what(MAGICAL_BREATHING));
if (Passes_walls)
+/*JP
you_can("walk through walls", from_what(PASSES_WALLS));
+*/
+ you_can("\95Ç\82ð\92Ê\82è\94²\82¯\82é\82±\82Æ\82ª", from_what(PASSES_WALLS));
/*** Physical attributes ***/
if (Regeneration)
+/*JP
enl_msg("You regenerate", "", "d", "", from_what(REGENERATION));
+*/
+ you_have("\8dÄ\90¶\94\\97Í", from_what(REGENERATION));
if (Slow_digestion)
+/*JP
you_have("slower digestion", from_what(SLOW_DIGESTION));
+*/
+ enl_msg("\90H\95¨\82Ì\8fÁ\89»\82ª\92x", "\82¢", "\82©\82Á\82½", "", from_what(SLOW_DIGESTION));
if (u.uhitinc)
+/*JP
you_have(enlght_combatinc("to hit", u.uhitinc, final, buf), "");
+*/
+ you_have(enlght_combatinc("\96½\92\86\97¦", u.uhitinc, final, buf), "");
if (u.udaminc)
+/*JP
you_have(enlght_combatinc("damage", u.udaminc, final, buf), "");
+*/
+ you_have(enlght_combatinc("\83_\83\81\81[\83W", u.udaminc, final, buf), "");
if (u.uspellprot || Protection) {
int prot = 0;
prot += u.ublessed;
prot += u.uspellprot;
if (prot)
+/*JP
you_have(enlght_combatinc("defense", prot, final, buf), "");
+*/
+ you_have(enlght_combatinc("\96h\8cä", prot, final, buf), "");
}
if ((armpro = magic_negation(&youmonst)) > 0) {
/* magic cancellation factor, conferred by worn armor */
static const char *const mc_types[] = {
+#if 0 /*JP:T*/
"" /*ordinary*/, "warded", "guarded", "protected",
+#else
+ "" /*ordinary*/, "\89q\82ç\82ê\82Ä", "\8cì\82ç\82ê\82Ä", "\8eç\82ç\82ê\82Ä",
+#endif
};
/* sanity check */
if (armpro >= SIZE(mc_types))
armpro = SIZE(mc_types) - 1;
+/*JP
you_are(mc_types[armpro], "");
+*/
+ you_are_ing(mc_types[armpro], "");
}
if (Half_physical_damage)
enlght_halfdmg(HALF_PHDAM, final);
enlght_halfdmg(HALF_SPDAM, final);
/* polymorph and other shape change */
if (Protection_from_shape_changers)
+#if 0 /*JP*/
you_are("protected from shape changers",
from_what(PROT_FROM_SHAPE_CHANGERS));
+#else
+ you_have("\95Ï\89»\89ö\95¨\82Ö\82Ì\91Ï\90«", from_what(PROT_FROM_SHAPE_CHANGERS));
+#endif
if (Unchanging) {
const char *what = 0;
if (!Upolyd) /* Upolyd handled below after current form */
+/*JP
you_can("not change from your current form",
+*/
+ you_are("\8c»\8dÝ\82Ì\8ep\82©\82ç\95Ï\89»\82Å\82«\82È\82¢\8fó\91Ô",
from_what(UNCHANGING));
/* blocked shape changes */
if (Polymorph)
+/*JP
what = !final ? "polymorph" : "have polymorphed";
+*/
+ what = "\95Ï\89»\82µ\82Ä";
else if (u.ulycn >= LOW_PM)
+/*JP
what = !final ? "change shape" : "have changed shape";
+*/
+ what = "\8ep\82ð\95Ï\82¦\82Ä";
if (what) {
+#if 0 /*JP*/
Sprintf(buf, "would %s periodically", what);
/* omit from_what(UNCHANGING); too verbose */
enl_msg(You_, buf, buf, " if not locked into your current form",
"");
+#else
+ Sprintf(buf, "\82à\82µ\8c»\8dÝ\82Ì\8ep\82É\8cÅ\92è\82³\82ê\82Ä\82¢\82È\82¯\82ê\82Î\92è\8aú\93I\82É%s", what);
+ you_are_ing(buf, "");
+#endif
}
} else if (Polymorph) {
+/*JP
you_are("polymorphing periodically", from_what(POLYMORPH));
+*/
+ you_are("\92è\8aú\93I\82É\95Ï\89»\82µ\82Ä", from_what(POLYMORPH));
}
if (Polymorph_control)
+/*JP
you_have("polymorph control", from_what(POLYMORPH_CONTROL));
- if (Upolyd && u.umonnum != u.ulycn) {
+*/
+ you_have("\95Ï\89»\82Ì\90§\8cä\94\\97Í", from_what(POLYMORPH_CONTROL));
+ if (Upolyd && u.umonnum != u.ulycn
+ /* if we've died from turning into slime, we're polymorphed
+ right now but don't want to list it as a temporary attribute
+ [we need a more reliable way to detect this situation] */
+ && !(final == ENL_GAMEOVERDEAD
+ && u.umonnum == PM_GREEN_SLIME && !Unchanging)) {
/* foreign shape (except were-form which is handled below) */
+/*JP
Sprintf(buf, "polymorphed into %s", an(youmonst.data->mname));
+*/
+ Sprintf(buf, "%s\82É\95Ï\89»\82µ\82Ä", youmonst.data->mname);
if (wizard)
Sprintf(eos(buf), " (%d)", u.mtimedone);
you_are(buf, "");
}
if (lays_eggs(youmonst.data) && flags.female) /* Upolyd */
+/*JP
you_can("lay eggs", "");
+*/
+ you_can("\97\91\82ð\8eY\82Þ\82±\82Æ\82ª", "");
if (u.ulycn >= LOW_PM) {
+#if 0 /*JP*/
/* "you are a werecreature [in beast form]" */
Strcpy(buf, an(mons[u.ulycn].mname));
if (u.umonnum == u.ulycn) {
if (wizard)
Sprintf(eos(buf), " (%d)", u.mtimedone);
}
+#else
+ /*JP:\81u\82 \82È\82½\82Í[\8fb\82Ì\8ep\82Ì]\81\9b\81\9b\90l\8aÔ\82Å\82 \82é\81v*/
+ buf[0] = '\0';
+ if (u.umonnum == u.ulycn) {
+ Strcpy(buf, "\8fb\82Ì\8ep\82Ì");
+ if (wizard)
+ Sprintf(eos(buf), " (%d)", u.mtimedone);
+ }
+ Strcat(buf, mons[u.ulycn].mname);
+#endif
you_are(buf, "");
}
if (Unchanging && Upolyd) /* !Upolyd handled above */
+/*JP
you_can("not change from your current form", from_what(UNCHANGING));
+*/
+ enl_msg("\8d¡\82Ì\8ep\82©\82ç\95Ï\89»\82·\82é\82±\82Æ\82ª\82Å\82«\82È", "\82¢", "\82©\82Á\82½", "", from_what(UNCHANGING));
if (Hate_silver)
+/*JP
you_are("harmed by silver", "");
+*/
+ enl_msg("\82 \82È\82½\82Í\8bâ\82É\8eã", "\82¢", "\82©\82Á\82½", "", "");
/* movement and non-armor-based protection */
if (Fast)
+/*JP
you_are(Very_fast ? "very fast" : "fast", from_what(FAST));
+*/
+ you_have(Very_fast ? "\82Æ\82Ä\82à\91f\91\81\82\8ds\93®\82·\82é\94\\97Í" : "\91f\91\81\82\8ds\93®\82·\82é\94\\97Í", from_what(FAST));
if (Reflecting)
+/*JP
you_have("reflection", from_what(REFLECTING));
+*/
+ you_have("\94½\8eË\94\\97Í", from_what(REFLECTING));
if (Free_action)
+/*JP
you_have("free action", from_what(FREE_ACTION));
+*/
+ you_have("\8dS\91©\82³\82ê\82È\82¢\94\\97Í", from_what(FREE_ACTION));
if (Fixed_abil)
+/*JP
you_have("fixed abilities", from_what(FIXED_ABIL));
+*/
+ enl_msg("\94\\97Í\82ª\95Ï\89»\82µ\82È", "\82¢", "\82©\82Á\82½", "", from_what(FIXED_ABIL));
if (Lifesaved)
+/*JP
enl_msg("Your life ", "will be", "would have been", " saved", "");
+*/
+ enl_msg("\82 \82È\82½\82Ì\90¶\96½\82Í\95Û\91¶\82³\82ê\82Ä", iru, ita, "", "");
/*** Miscellany ***/
if (Luck) {
ltmp = abs((int) Luck);
+#if 0 /*JP:T*/
Sprintf(buf, "%s%slucky",
ltmp >= 10 ? "extremely " : ltmp >= 5 ? "very " : "",
Luck < 0 ? "un" : "");
+#else
+ Sprintf(buf, "%s%s",
+ ltmp >= 10 ? "\96Ò\97ó\82É" : ltmp >= 5 ? "\82Æ\82Ä\82à" : "",
+ Luck < 0 ? "\95s\8dK" : "\8dK\95\9f");
+#endif
if (wizard)
Sprintf(eos(buf), " (%d)", Luck);
you_are(buf, "");
} else if (wizard)
+/*JP
enl_msg("Your luck ", "is", "was", " zero", "");
+*/
+ enl_msg("\82 \82È\82½\82Ì\89^\82Í\83[\83\8d", "\82Å\82 \82é", "\82¾\82Á\82½", "", "");
if (u.moreluck > 0)
+/*JP
you_have("extra luck", "");
+*/
+ you_have("\82³\82ç\82È\82é\8dK\89^", "");
else if (u.moreluck < 0)
+/*JP
you_have("reduced luck", "");
+*/
+ you_have("\82³\82ç\82È\82é\95s\89^", "");
if (carrying(LUCKSTONE) || stone_luck(TRUE)) {
- ltmp = stone_luck(0);
+ ltmp = stone_luck(FALSE);
if (ltmp <= 0)
+/*JP
enl_msg("Bad luck ", "does", "did", " not time out for you", "");
+*/
+ enl_msg("\95s\89^\82Í\8e\9e\8aÔ\90Ø\82ê\82É\82È\82ç\82È", "\82¢", "\82©\82Á\82½", "", "");
if (ltmp >= 0)
+/*JP
enl_msg("Good luck ", "does", "did", " not time out for you", "");
+*/
+ enl_msg("\8dK\89^\82Í\8e\9e\8aÔ\90Ø\82ê\82É\82È\82ç\82È", "\82¢", "\82©\82Á\82½", "", "");
}
if (u.ugangr) {
+#if 0 /*JP*/
Sprintf(buf, " %sangry with you",
u.ugangr > 6 ? "extremely " : u.ugangr > 3 ? "very " : "");
+#else
+ Sprintf(buf, "%s\82Í%s\93{\82Á\82Ä%s", u_gname(),
+ u.ugangr > 6 ? "\96Ò\97ó\82É" : u.ugangr > 3 ? "\82Æ\82Ä\82à" : "", final ? ita : iru);
+#endif
if (wizard)
Sprintf(eos(buf), " (%d)", u.ugangr);
+#if 0 /*JP*/
enl_msg(u_gname(), " is", " was", buf, "");
+#else
+ enl_msg(buf, "", "", "", "");
+#endif
} else {
/*
* We need to suppress this when the game is over, because death
}
}
- /* named fruit debugging (doesn't really belong here...) */
- if (wizard) {
- int fcount = 0;
+#ifdef DEBUG
+ /* named fruit debugging (doesn't really belong here...); to enable,
+ include 'fruit' in DEBUGFILES list (even though it isn't a file...) */
+ if (wizard && explicitdebug("fruit")) {
struct fruit *f;
- char buf2[BUFSZ];
+ reorder_fruit(TRUE); /* sort by fruit index, from low to high;
+ * this modifies the ffruit chain, so could
+ * possibly mask or even introduce a problem,
+ * but it does useful sanity checking */
for (f = ffruit; f; f = f->nextf) {
- Sprintf(buf, "Fruit %d ", ++fcount);
- Sprintf(buf2, "%s (id %d)", f->fname, f->fid);
- enl_msg(buf, "is ", "was ", buf2, "");
+/*JP
+ Sprintf(buf, "Fruit #%d ", f->fid);
+*/
+ Sprintf(buf, "fruit $%d \82Í", f->fid);
+/*JP
+ enl_msg(buf, "is ", "was ", f->fname, "");
+*/
+ enl_msg(buf, "\82¾", "\82¾\82Á\82½", f->fname, "");
}
+/*JP
enl_msg("The current fruit ", "is ", "was ", pl_fruit, "");
+*/
+ enl_msg("\8c»\8dÝ\82Ì fruit \82Í", "\82¾", "\82¾\82Á\82½", pl_fruit, "");
Sprintf(buf, "%d", flags.made_fruit);
+/*JP
enl_msg("The made fruit flag ", "is ", "was ", buf, "");
+*/
+ enl_msg("made fruit flag \82Í", "\82¾", "\82¾\82Á\82½", buf, "");
}
+#endif
{
const char *p;
case 1:
break; /* just "are dead" */
default:
-#if 0 /*JP*/
+#if 0 /*JP:T*/
Sprintf(buf, " (%d%s time!)", u.umortality,
ordin(u.umortality));
#else
tmpwin = create_nhwindow(NHW_MENU);
start_menu(tmpwin);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, iflags.menu_headings,
+/*JP
"Starting", FALSE);
+*/
+ "\8aJ\8en", FALSE);
/* Starting name, race, role, gender */
+/*JP
Sprintf(buf, fmtstr, "name", plname);
+*/
+ Sprintf(buf, fmtstr, "\96¼\91O", plname);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
+/*JP
Sprintf(buf, fmtstr, "race", urace.noun);
+*/
+ Sprintf(buf, fmtstr, "\8eí\91°", urace.noun);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
+/*JP
Sprintf(buf, fmtstr, "role",
+*/
+ Sprintf(buf, fmtstr, "\90E\8bÆ",
(flags.initgend && urole.name.f) ? urole.name.f : urole.name.m);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
+/*JP
Sprintf(buf, fmtstr, "gender", genders[flags.initgend].adj);
+*/
+ Sprintf(buf, fmtstr, "\90«\95Ê", genders[flags.initgend].adj);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
/* Starting alignment */
+/*JP
Sprintf(buf, fmtstr, "alignment", align_str(u.ualignbase[A_ORIGINAL]));
+*/
+ Sprintf(buf, fmtstr, "\91®\90«", align_str(u.ualignbase[A_ORIGINAL]));
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
/* Current name, race, role, gender */
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, "", FALSE);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, iflags.menu_headings,
+/*JP
"Current", FALSE);
+*/
+ "\8c»\8dÝ", FALSE);
+/*JP
Sprintf(buf, fmtstr, "race", Upolyd ? youmonst.data->mname : urace.noun);
+*/
+ Sprintf(buf, fmtstr, "\8eí\91°", Upolyd ? youmonst.data->mname : urace.noun);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
if (Upolyd) {
+/*JP
Sprintf(buf, fmtstr, "role (base)",
+*/
+ Sprintf(buf, fmtstr, "\90E\8bÆ(\8aî\96{)",
(u.mfemale && urole.name.f) ? urole.name.f
: urole.name.m);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
} else {
+/*JP
Sprintf(buf, fmtstr, "role",
+*/
+ Sprintf(buf, fmtstr, "\90E\8bÆ",
(flags.female && urole.name.f) ? urole.name.f
: urole.name.m);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
}
/* don't want poly_gender() here; it forces `2' for non-humanoids */
genidx = is_neuter(youmonst.data) ? 2 : flags.female;
+/*JP
Sprintf(buf, fmtstr, "gender", genders[genidx].adj);
+*/
+ Sprintf(buf, fmtstr, "\90«\95Ê", genders[genidx].adj);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
if (Upolyd && (int) u.mfemale != genidx) {
+/*JP
Sprintf(buf, fmtstr, "gender (base)", genders[u.mfemale].adj);
+*/
+ Sprintf(buf, fmtstr, "\90«\95Ê(\8aî\96{)", genders[u.mfemale].adj);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
}
/* Current alignment */
+/*JP
Sprintf(buf, fmtstr, "alignment", align_str(u.ualign.type));
+*/
+ Sprintf(buf, fmtstr, "\91®\90«", align_str(u.ualign.type));
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
/* Deity list */
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, "", FALSE);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, iflags.menu_headings,
+/*JP
"Deities", FALSE);
+*/
+ "\90_", FALSE);
+#if 0 /*JP:T*/
Sprintf(buf2, deity_fmtstr, align_gname(A_CHAOTIC),
(u.ualignbase[A_ORIGINAL] == u.ualign.type
&& u.ualign.type == A_CHAOTIC) ? " (s,c)"
: (u.ualignbase[A_ORIGINAL] == A_CHAOTIC) ? " (s)"
: (u.ualign.type == A_CHAOTIC) ? " (c)" : "");
+#else
+ Sprintf(buf2, deity_fmtstr, align_gname(A_CHAOTIC),
+ (u.ualignbase[A_ORIGINAL] == u.ualign.type
+ && u.ualign.type == A_CHAOTIC) ? " (\8f\89\81C\8c»)"
+ : (u.ualignbase[A_ORIGINAL] == A_CHAOTIC) ? " (\8f\89)"
+ : (u.ualign.type == A_CHAOTIC) ? " (\8c»)" : "");
+#endif
+/*JP
Sprintf(buf, fmtstr, "Chaotic", buf2);
+*/
+ Sprintf(buf, fmtstr, "\8d¬\93×", buf2);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
+#if 0 /*JP:T*/
Sprintf(buf2, deity_fmtstr, align_gname(A_NEUTRAL),
(u.ualignbase[A_ORIGINAL] == u.ualign.type
&& u.ualign.type == A_NEUTRAL) ? " (s,c)"
: (u.ualignbase[A_ORIGINAL] == A_NEUTRAL) ? " (s)"
: (u.ualign.type == A_NEUTRAL) ? " (c)" : "");
+#else
+ Sprintf(buf2, deity_fmtstr, align_gname(A_NEUTRAL),
+ (u.ualignbase[A_ORIGINAL] == u.ualign.type
+ && u.ualign.type == A_NEUTRAL) ? " (\8f\89\81C\8c»)"
+ : (u.ualignbase[A_ORIGINAL] == A_NEUTRAL) ? " (\8f\89)"
+ : (u.ualign.type == A_NEUTRAL) ? " (\8c»)" : "");
+#endif
+/*JP
Sprintf(buf, fmtstr, "Neutral", buf2);
+*/
+ Sprintf(buf, fmtstr, "\92\86\97§", buf2);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
+#if 0 /*JP:T*/
Sprintf(buf2, deity_fmtstr, align_gname(A_LAWFUL),
(u.ualignbase[A_ORIGINAL] == u.ualign.type
&& u.ualign.type == A_LAWFUL) ? " (s,c)"
: (u.ualignbase[A_ORIGINAL] == A_LAWFUL) ? " (s)"
: (u.ualign.type == A_LAWFUL) ? " (c)" : "");
+#else
+ Sprintf(buf2, deity_fmtstr, align_gname(A_LAWFUL),
+ (u.ualignbase[A_ORIGINAL] == u.ualign.type
+ && u.ualign.type == A_LAWFUL) ? " (\8f\89\81C\8c»)"
+ : (u.ualignbase[A_ORIGINAL] == A_LAWFUL) ? " (\8f\89)"
+ : (u.ualign.type == A_LAWFUL) ? " (\8c»)" : "");
+#endif
+/*JP
Sprintf(buf, fmtstr, "Lawful", buf2);
+*/
+ Sprintf(buf, fmtstr, "\92\81\8f\98", buf2);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, FALSE);
+/*JP
end_menu(tmpwin, "Base Attributes");
+*/
+ end_menu(tmpwin, "\8aî\96{\91®\90«");
n = select_menu(tmpwin, PICK_NONE, &selected);
destroy_nhwindow(tmpwin);
return (boolean) (n != -1);
{
char *bp, buf[BUFSZ];
+/*JP
Strcpy(buf, "hiding");
- if (youmonst.m_ap_type != M_AP_NOTHING) {
+*/
+ Strcpy(buf, "\89B\82ê");
+ if (U_AP_TYPE != M_AP_NOTHING) {
/* mimic; hero is only able to mimic a strange object or gold
or hallucinatory alternative to gold, so we skip the details
for the hypothetical furniture and monster cases */
+#if 0 /*JP*//*\8cã\82ë\82É\89ñ\82·*//* not used */
bp = eos(strcpy(buf, "mimicking"));
- if (youmonst.m_ap_type == M_AP_OBJECT) {
+#endif
+ if (U_AP_TYPE == M_AP_OBJECT) {
+/*JP
Sprintf(bp, " %s", an(simple_typename(youmonst.mappearance)));
- } else if (youmonst.m_ap_type == M_AP_FURNITURE) {
+*/
+ Strcpy(buf, simple_typename(youmonst.mappearance));
+ } else if (U_AP_TYPE == M_AP_FURNITURE) {
+/*JP
Strcpy(bp, " something");
- } else if (youmonst.m_ap_type == M_AP_MONSTER) {
+*/
+ Strcpy(buf, "\89½\82©");
+ } else if (U_AP_TYPE == M_AP_MONSTER) {
+/*JP
Strcpy(bp, " someone");
+*/
+ Strcpy(buf, "\89½\8eÒ\82©");
} else {
; /* something unexpected; leave 'buf' as-is */
}
+#if 1 /*JP*//*\82±\82±\82Å\92Ç\89Á*/
+ Strcat(buf, "\82Ì\82Ó\82è\82ð\82µ");
+#endif
} else if (u.uundetected) {
bp = eos(buf); /* points past "hiding" */
if (youmonst.data->mlet == S_EEL) {
if (is_pool(u.ux, u.uy))
+/*JP
Sprintf(bp, " in the %s", waterbody_name(u.ux, u.uy));
+*/
+ Sprintf(bp, "%s\82Ì\92\86\82É", waterbody_name(u.ux, u.uy));
} else if (hides_under(youmonst.data)) {
struct obj *o = level.objects[u.ux][u.uy];
if (o)
+/*JP
Sprintf(bp, " underneath %s", ansimpleoname(o));
+*/
+ Sprintf(bp, "%s\82Ì\89º\82É", ansimpleoname(o));
} else if (is_clinger(youmonst.data) || Flying) {
/* Flying: 'lurker above' hides on ceiling but doesn't cling */
+/*JP
Sprintf(bp, " on the %s", ceiling(u.ux, u.uy));
+*/
+ Sprintf(bp, "%s\82É", ceiling(u.ux, u.uy));
} else {
/* on floor; is_hider() but otherwise not special: 'trapper' */
if (u.utrap && u.utraptype == TT_PIT) {
struct trap *t = t_at(u.ux, u.uy);
+#if 0 /*JP:T*/
Sprintf(bp, " in a %spit",
(t && t->ttyp == SPIKED_PIT) ? "spiked " : "");
+#else
+ Sprintf(bp, "%s\97\8e\82µ\8c\8a\82Ì\92\86\82É",
+ (t && t->ttyp == SPIKED_PIT) ? "\83g\83Q\82¾\82ç\82¯\82Ì" : "");
+#endif
} else
+/*JP
Sprintf(bp, " on the %s", surface(u.ux, u.uy));
+*/
+ Sprintf(bp, "%s\82É", surface(u.ux, u.uy));
}
+#if 1 /*JP*//*\82±\82±\82Å\92Ç\89Á*/
+ Strcat(buf, "\89B\82ê");
+#endif
} else {
; /* shouldn't happen; will result in generic "you are hiding" */
}
you_are(buf, "");
} else {
/* for dohide(), when player uses '#monster' command */
+#if 0 /*JP*/
You("are %s %s.", msgflag ? "already" : "now", buf);
+#else
+ if (msgflag) {
+ You("\82·\82Å\82É%s\82Ä\82¢\82é\81D", buf);
+ } else {
+ You("%s\82½\81D", buf);
+ }
+#endif
}
}
/* KMH, #conduct
* (shares enlightenment's tense handling)
*/
-STATIC_PTR int
+int
doconduct(VOID_ARGS)
{
show_conduct(0);
enl_msg(You_, "have gone", "went", " without food", "");
*/
enl_msg("\82 \82È\82½\82Í\90H\8e\96\82ð\82µ", "\82Ä\82¢\82È\82¢", "\82È\82©\82Á\82½", "", "");
- /* But beverages are okay */
+ /* but beverages are okay */
else if (!u.uconduct.unvegan)
/*JP
you_have_X("followed a strict vegan diet");
*/
you_have_never("\82 \82È\82½\82Í\91\95\94õ\82µ\82Ä\82¢\82é\95\90\8aí\82Å\8dU\8c\82\82µ");
} else if (wizard) {
-#if 0 /*JP*/
+#if 0 /*JP:T*/
Sprintf(buf, "used a wielded weapon %ld time%s", u.uconduct.weaphit,
plur(u.uconduct.weaphit));
you_have_X(buf);
*/
you_have_never("\82 \82È\82½\82Í\93Ç\82Ý\8f\91\82«\82µ");
} else if (wizard) {
-#if 0 /*JP*/
+#if 0 /*JP:T*/
Sprintf(buf, "read items or engraved %ld time%s", u.uconduct.literate,
plur(u.uconduct.literate));
you_have_X(buf);
*/
you_have_never("\82 \82È\82½\82Í\89ö\95¨\82ð\8bs\8eE\82µ");
} else {
-#if 0 /*JP*/
+#if 0 /*JP:T*/
Sprintf(buf, "genocided %d type%s of monster%s", ngenocided,
plur(ngenocided), plur(ngenocided));
you_have_X(buf);
*/
you_have_never("\82 \82È\82½\82Í\95¨\91Ì\82ð\95Ï\89»\82³\82¹");
} else if (wizard) {
-#if 0 /*JP*/
+#if 0 /*JP:T*/
Sprintf(buf, "polymorphed %ld item%s", u.uconduct.polypiles,
plur(u.uconduct.polypiles));
you_have_X(buf);
#else
- Sprintf(buf, "%ld\8cÂ\82Ì\93¹\8bï\82ð\95Ï\89»\82³\82¹", u.uconduct.polypiles);
+ Sprintf(buf, "%ld\8cÂ\82Ì\95¨\82ð\95Ï\89»\82³\82¹", u.uconduct.polypiles);
you_have_X(buf);
#endif
}
*/
you_have_never("\82 \82È\82½\82Í\95Ï\89»\82µ");
} else if (wizard) {
-#if 0 /*JP*/
+#if 0 /*JP:T*/
Sprintf(buf, "changed form %ld time%s", u.uconduct.polyselfs,
plur(u.uconduct.polyselfs));
you_have_X(buf);
*/
you_have_never("\82 \82È\82½\82Í\8aè\82¢\8e\96\82ð\82µ");
} else {
-#if 0 /*JP*/
+#if 0 /*JP:T*/
Sprintf(buf, "used %ld wish%s", u.uconduct.wishes,
(u.uconduct.wishes > 1L) ? "es" : "");
- you_have_X(buf);
#else
Sprintf(buf, "%ld\89ñ\8aè\82¢\8e\96\82ð\82µ", u.uconduct.wishes);
- you_have_X(buf);
#endif
+ if (u.uconduct.wisharti) {
+ /* if wisharti == wishes
+ * 1 wish (for an artifact)
+ * 2 wishes (both for artifacts)
+ * N wishes (all for artifacts)
+ * else (N is at least 2 in order to get here; M < N)
+ * N wishes (1 for an artifact)
+ * N wishes (M for artifacts)
+ */
+#if 0 /*JP*/
+ if (u.uconduct.wisharti == u.uconduct.wishes)
+ Sprintf(eos(buf), " (%s",
+ (u.uconduct.wisharti > 2L) ? "all "
+ : (u.uconduct.wisharti == 2L) ? "both " : "");
+ else
+ Sprintf(eos(buf), " (%ld ", u.uconduct.wisharti);
+
+ Sprintf(eos(buf), "for %s)",
+ (u.uconduct.wisharti == 1L) ? "an artifact"
+ : "artifacts");
+#else
+ Sprintf(eos(buf), " (\90¹\8aí\82Í%ld\89ñ)", u.uconduct.wisharti);
+#endif
+ }
+ you_have_X(buf);
if (!u.uconduct.wisharti)
#if 0 /*JP*/
en_win = WIN_ERR;
}
-#ifndef M
-#ifndef NHSTDC
-#define M(c) (0x80 | (c))
+/* ordered by command name */
+struct ext_func_tab extcmdlist[] = {
+ { '#', "#", "perform an extended command",
+ doextcmd, IFBURIED | GENERALCMD },
+#if 0 /*JP:T*/
+ { M('?'), "?", "list all extended commands",
#else
-#define M(c) ((c) -128)
-#endif /* NHSTDC */
+ { M('?'), "?", "\82±\82Ì\8ag\92£\83R\83}\83\93\83h\88ê\97\97\82ð\95\\8e¦\82·\82é",
#endif
-#ifndef C
-#define C(c) (0x1f & (c))
+ doextlist, IFBURIED | AUTOCOMPLETE | GENERALCMD },
+#if 0 /*JP:T*/
+ { M('a'), "adjust", "adjust inventory letters",
+#else
+ { M('a'), "adjust", "\8e\9d\82¿\95¨\88ê\97\97\82Ì\92²\90®",
+#endif
+ doorganize, IFBURIED | AUTOCOMPLETE },
+#if 0 /*JP:T*/
+ { M('A'), "annotate", "name current level",
+#else
+ { M('A'), "annotate", "\8c»\8dÝ\82Ì\8aK\82É\96¼\91O\82ð\82Â\82¯\82é",
+#endif
+ donamelevel, IFBURIED | AUTOCOMPLETE },
+#if 0 /*JP*/
+ { 'a', "apply", "apply (use) a tool (pick-axe, key, lamp...)",
+#else
+ { 'a', "apply", "\93¹\8bï\82ð\8eg\82¤\81D(\82Â\82é\82Í\82µ, \8c®, \83\89\83\93\83v\81c)",
+#endif
+ doapply },
+ { C('x'), "attributes", "show your attributes",
+ doattributes, IFBURIED },
+#if 0 /*JP:T*/
+ { '@', "autopickup", "toggle the pickup option on/off",
+#else
+ { '@', "autopickup", "\8e©\93®\8fE\82¢\83I\83v\83V\83\87\83\93\82ð\90Ø\82è\91Ö\82¦\82é",
+#endif
+ dotogglepickup, IFBURIED },
+#if 0 /*JP:T*/
+ { 'C', "call", "call (name) something", docallcmd, IFBURIED },
+#else
+ { 'C', "call", "\96¼\91O\82ð\82Â\82¯\82é", docallcmd, IFBURIED },
+#endif
+#if 0 /*JP:T*/
+ { 'Z', "cast", "zap (cast) a spell", docast, IFBURIED },
+#else
+ { 'Z', "cast", "\8eô\95¶\82ð\8f¥\82¦\82é", docast, IFBURIED },
+#endif
+#if 0 /*JP:T*/
+ { M('c'), "chat", "talk to someone", dotalk, IFBURIED | AUTOCOMPLETE },
+#else
+ { M('c'), "chat", "\92N\82©\82Æ\98b\82·", dotalk, IFBURIED | AUTOCOMPLETE },
+#endif
+#if 0 /*JP:T*/
+ { 'c', "close", "close a door", doclose },
+#else
+ { 'c', "close", "\83h\83A\82ð\95Â\82ß\82é", doclose },
+#endif
+#if 0 /*JP:T*/
+ { M('C'), "conduct", "list voluntary challenges you have maintained",
+#else
+ { M('C'), "conduct", "\82Ç\82¤\82¢\82¤\8ds\93®\82ð\82Æ\82Á\82½\82©\8c©\82é",
+#endif
+ doconduct, IFBURIED | AUTOCOMPLETE },
+#if 0 /*JP:T*/
+ { M('d'), "dip", "dip an object into something", dodip, AUTOCOMPLETE },
+#else
+ { M('d'), "dip", "\89½\82©\82É\95¨\82ð\90Z\82·", dodip, AUTOCOMPLETE },
+#endif
+ { '>', "down", "go down a staircase", dodown },
+ { 'd', "drop", "drop an item", dodrop },
+ { 'D', "droptype", "drop specific item types", doddrop },
+ { 'e', "eat", "eat something", doeat },
+ { 'E', "engrave", "engrave writing on the floor", doengrave },
+#if 0 /*JP:T*/
+ { M('e'), "enhance", "advance or check weapon and spell skills",
+#else
+ { M('e'), "enhance", "\95\90\8aí\8fn\97û\93x\82ð\8d\82\82ß\82é",
+#endif
+ enhance_weapon_skill, IFBURIED | AUTOCOMPLETE },
+#if 0 /*JP:T*/
+ { '\0', "exploremode", "enter explore (discovery) mode",
+#else
+ { '\0', "exploremode", "\92T\8c\9f(\94\8c©)\83\82\81[\83h\82É\93ü\82é",
+#endif
+ enter_explore_mode, IFBURIED },
+ { 'f', "fire", "fire ammunition from quiver", dofire },
+#if 0 /*JP:T*/
+ { M('f'), "force", "force a lock", doforce, AUTOCOMPLETE },
+#else
+ { M('f'), "force", "\8c®\82ð\82±\82¶\82 \82¯\82é", doforce, AUTOCOMPLETE },
+#endif
+ { ';', "glance", "show what type of thing a map symbol corresponds to",
+ doquickwhatis, IFBURIED | GENERALCMD },
+ { '?', "help", "give a help message", dohelp, IFBURIED | GENERALCMD },
+ { '\0', "herecmdmenu", "show menu of commands you can do here",
+ doherecmdmenu, IFBURIED },
+ { 'V', "history", "show long version and game history",
+ dohistory, IFBURIED | GENERALCMD },
+ { 'i', "inventory", "show your inventory", ddoinv, IFBURIED },
+ { 'I', "inventtype", "inventory specific item types",
+ dotypeinv, IFBURIED },
+#if 0 /*JP:T*/
+ { M('i'), "invoke", "invoke an object's special powers",
+#else
+ { M('i'), "invoke", "\95¨\82Ì\93Á\95Ê\82È\97Í\82ð\8eg\82¤",
+#endif
+ doinvoke, IFBURIED | AUTOCOMPLETE },
+#if 0 /*JP:T*/
+ { M('j'), "jump", "jump to another location", dojump, AUTOCOMPLETE },
+#else
+ { M('j'), "jump", "\91¼\82Ì\88Ê\92u\82É\94ò\82Ñ\82¤\82Â\82é", dojump, AUTOCOMPLETE },
+#endif
+ { C('d'), "kick", "kick something", dokick },
+ { '\\', "known", "show what object types have been discovered",
+ dodiscovered, IFBURIED | GENERALCMD },
+ { '`', "knownclass", "show discovered types for one class of objects",
+ doclassdisco, IFBURIED | GENERALCMD },
+#if 0 /*JP:T*/
+ { '\0', "levelchange", "change experience level",
+#else
+ { '\0', "levelchange", "\8co\8c±\83\8c\83x\83\8b\82ð\95Ï\82¦\82é",
+#endif
+ wiz_level_change, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+#if 0 /*JP:T*/
+ { '\0', "lightsources", "show mobile light sources",
+#else
+ { '\0', "lightsources", "\88Ú\93®\8cõ\8c¹\82ð\8c©\82é",
+#endif
+ wiz_light_sources, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+ { ':', "look", "look at what is here", dolook, IFBURIED },
+#if 0 /*JP:T*/
+ { M('l'), "loot", "loot a box on the floor", doloot, AUTOCOMPLETE },
+#else
+ { M('l'), "loot", "\8f°\82Ì\8fã\82Ì\94 \82ð\8aJ\82¯\82é", doloot, AUTOCOMPLETE },
+#endif
+#ifdef DEBUG_MIGRATING_MONS
+#if 0 /*JP:T*/
+ { '\0', "migratemons", "migrate N random monsters",
+#else
+ { '\0', "migratemons", "\83\89\83\93\83_\83\80\82È\89ö\95¨\82ð\89½\91Ì\82©\88Ú\8fZ\82³\82¹\82é",
+#endif
+ wiz_migrate_mons, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+#endif
+#if 0 /*JP:T*/
+ { M('m'), "monster", "use monster's special ability",
+#else
+ { M('m'), "monster", "\89ö\95¨\82Ì\93Á\95Ê\94\\97Í\82ð\8eg\82¤",
+#endif
+ domonability, IFBURIED | AUTOCOMPLETE },
+#if 0 /*JP:T*/
+ { 'N', "name", "name a monster or an object",
+#else
+ { 'N', "name", "\83A\83C\83e\83\80\82â\95¨\82É\96¼\91O\82ð\82Â\82¯\82é",
+#endif
+ docallcmd, IFBURIED | AUTOCOMPLETE },
+#if 0 /*JP:T*/
+ { M('o'), "offer", "offer a sacrifice to the gods",
+#else
+ { M('o'), "offer", "\90_\82É\8b\9f\95¨\82ð\95ù\82°\82é",
+#endif
+ dosacrifice, AUTOCOMPLETE },
+ { 'o', "open", "open a door", doopen },
+ { 'O', "options", "show option settings, possibly change them",
+ doset, IFBURIED | GENERALCMD },
+#if 0 /*JP:T*/
+ { C('o'), "overview", "show a summary of the explored dungeon",
+#else
+ { C('o'), "overview", "\92T\8dõ\82µ\82½\96À\8b{\82Ì\8aT\97v\82ð\95\\8e¦\82·\82é",
+#endif
+ dooverview, IFBURIED | AUTOCOMPLETE },
+#if 0 /*JP:T*/
+ { '\0', "panic", "test panic routine (fatal to game)",
+#else
+ { '\0', "panic", "\83p\83j\83b\83N\83\8b\81[\83`\83\93\82ð\83e\83X\83g\82·\82é(\92v\96½\93I)",
+#endif
+ wiz_panic, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+ { 'p', "pay", "pay your shopping bill", dopay },
+ { ',', "pickup", "pick up things at the current location", dopickup },
+#if 0 /*JP:T*/
+ { '\0', "polyself", "polymorph self",
+#else
+ { '\0', "polyself", "\95Ï\89»\82·\82é",
+#endif
+ wiz_polyself, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+#if 0 /*JP:T*/
+ { M('p'), "pray", "pray to the gods for help",
+#else
+ { M('p'), "pray", "\90_\82É\8bF\82é",
+#endif
+ dopray, IFBURIED | AUTOCOMPLETE },
+ { C('p'), "prevmsg", "view recent game messages",
+ doprev_message, IFBURIED | GENERALCMD },
+ { 'P', "puton", "put on an accessory (ring, amulet, etc)", doputon },
+ { 'q', "quaff", "quaff (drink) something", dodrink },
+#if 0 /*JP:T*/
+ { M('q'), "quit", "exit without saving current game",
+#else
+ { M('q'), "quit", "\83Z\81[\83u\82µ\82È\82¢\82Å\8fI\97¹",
+#endif
+ done2, IFBURIED | AUTOCOMPLETE | GENERALCMD },
+ { 'Q', "quiver", "select ammunition for quiver", dowieldquiver },
+ { 'r', "read", "read a scroll or spellbook", doread },
+ { C('r'), "redraw", "redraw screen", doredraw, IFBURIED | GENERALCMD },
+ { 'R', "remove", "remove an accessory (ring, amulet, etc)", doremring },
+#if 0 /*JP:T*/
+ { M('R'), "ride", "mount or dismount a saddled steed",
+#else
+ { M('R'), "ride", "\89ö\95¨\82É\8fæ\82é(\82Ü\82½\82Í\8d~\82è\82é)",
+#endif
+ doride, AUTOCOMPLETE },
+#if 0 /*JP:T*/
+ { M('r'), "rub", "rub a lamp or a stone", dorub, AUTOCOMPLETE },
+#else
+ { M('r'), "rub", "\83\89\83\93\83v\82ð\82±\82·\82é", dorub, AUTOCOMPLETE },
+#endif
+ { 'S', "save", "save the game and exit", dosave, IFBURIED | GENERALCMD },
+#if 0 /*JP:T*/
+ { 's', "search", "search for traps and secret doors",
+ dosearch, IFBURIED, "searching" },
+#else
+ { 's', "search", "ã©\82â\89B\82µ\94à\82ð\92T\82·",
+ dosearch, IFBURIED, "\92T\82·" },
+#endif
+ { '*', "seeall", "show all equipment in use", doprinuse, IFBURIED },
+ { AMULET_SYM, "seeamulet", "show the amulet currently worn",
+ dopramulet, IFBURIED },
+ { ARMOR_SYM, "seearmor", "show the armor currently worn",
+ doprarm, IFBURIED },
+ { GOLD_SYM, "seegold", "count your gold", doprgold, IFBURIED },
+#if 0 /*JP:T*/
+ { '\0', "seenv", "show seen vectors",
+#else
+ { '\0', "seenv", "\8e\8b\90ü\83x\83N\83g\83\8b\82ð\8c©\82é",
+#endif
+ wiz_show_seenv, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+ { RING_SYM, "seerings", "show the ring(s) currently worn",
+ doprring, IFBURIED },
+ { SPBOOK_SYM, "seespells", "list and reorder known spells",
+ dovspell, IFBURIED },
+ { TOOL_SYM, "seetools", "show the tools currently in use",
+ doprtool, IFBURIED },
+ { '^', "seetrap", "show the type of adjacent trap", doidtrap, IFBURIED },
+ { WEAPON_SYM, "seeweapon", "show the weapon currently wielded",
+ doprwep, IFBURIED },
+ { '!', "shell", "do a shell escape",
+ dosh_core, IFBURIED | GENERALCMD
+#ifndef SHELL
+ | CMD_NOT_AVAILABLE
+#endif /* SHELL */
+ },
+#if 0 /*JP:T*/
+ { M('s'), "sit", "sit down", dosit, AUTOCOMPLETE },
+#else
+ { M('s'), "sit", "\8dÀ\82é", dosit, AUTOCOMPLETE },
+#endif
+#if 0 /*JP:T*/
+ { '\0', "stats", "show memory statistics",
+#else
+ { '\0', "stats", "\83\81\83\82\83\8a\8fó\91Ô\82ð\8c©\82é",
+#endif
+ wiz_show_stats, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+ { C('z'), "suspend", "suspend the game",
+ dosuspend_core, IFBURIED | GENERALCMD
+#ifndef SUSPEND
+ | CMD_NOT_AVAILABLE
+#endif /* SUSPEND */
+ },
+ { 'x', "swap", "swap wielded and secondary weapons", doswapweapon },
+ { 'T', "takeoff", "take off one piece of armor", dotakeoff },
+ { 'A', "takeoffall", "remove all armor", doddoremarm },
+ { C('t'), "teleport", "teleport around the level", dotelecmd, IFBURIED },
+#if 0 /*JP:T*/
+ { '\0', "terrain", "show map without obstructions",
+#else
+ { '\0', "terrain", "\8e×\96\82\82³\82ê\82¸\82É\92n\90}\82ð\8c©\82é",
#endif
+ doterrain, IFBURIED | AUTOCOMPLETE },
+ { '\0', "therecmdmenu",
+ "menu of commands you can do from here to adjacent spot",
+ dotherecmdmenu },
+ { 't', "throw", "throw something", dothrow },
+#if 0 /*JP:T*/
+ { '\0', "timeout", "look at timeout queue and hero's timed intrinsics",
+#else
+ { '\0', "timeout", "\8e\9e\8aÔ\90Ø\82ê\83L\83\85\81[\82Æ\83v\83\8c\83C\83\84\81[\82Ì\8e\9e\8aÔ\8co\89ß\82ð\8c©\82é",
+#endif
+ wiz_timeout_queue, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+#if 0 /*JP:T*/
+ { M('T'), "tip", "empty a container", dotip, AUTOCOMPLETE },
+#else
+ { M('T'), "tip", "\93ü\82ê\95¨\82ð\8bó\82É\82·\82é", dotip, AUTOCOMPLETE },
+#endif
+ { '_', "travel", "travel to a specific location on the map", dotravel },
+#if 0 /*JP:T*/
+ { M('t'), "turn", "turn undead away", doturn, IFBURIED | AUTOCOMPLETE },
+#else
+ { M('t'), "turn", "\83A\83\93\83f\83b\83g\82ð\93y\82É\95Ô\82·", doturn, IFBURIED | AUTOCOMPLETE },
+#endif
+#if 0 /*JP:T*/
+ { 'X', "twoweapon", "toggle two-weapon combat",
+#else
+ { 'X', "twoweapon", "\97¼\8eè\8e\9d\82¿\82Ì\90Ø\82è\91Ö\82¦",
+#endif
+ dotwoweapon, AUTOCOMPLETE },
+#if 0 /*JP:T*/
+ { M('u'), "untrap", "untrap something", dountrap, AUTOCOMPLETE },
+#else
+ { M('u'), "untrap", "ã©\82ð\82Í\82¸\82·", dountrap, AUTOCOMPLETE },
+#endif
+ { '<', "up", "go up a staircase", doup },
+#if 0 /*JP:T*/
+ { '\0', "vanquished", "list vanquished monsters",
+#else
+ { '\0', "vanquished", "\93|\82µ\82½\89ö\95¨\82Ì\88ê\97\97\82ð\8c©\82é",
+#endif
+ dovanquished, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+ { M('v'), "version",
+#if 0 /*JP:T*/
+ "list compile time options for this version of NetHack",
+#else
+ "\83R\83\93\83p\83C\83\8b\8e\9e\82Ì\83I\83v\83V\83\87\83\93\82ð\95\\8e¦\82·\82é",
+#endif
+ doextversion, IFBURIED | AUTOCOMPLETE | GENERALCMD },
+ { 'v', "versionshort", "show version", doversion, IFBURIED | GENERALCMD },
+#if 0 /*JP:T*/
+ { '\0', "vision", "show vision array",
+#else
+ { '\0', "vision", "\8e\8b\8aE\94z\97ñ\82ð\8c©\82é",
+#endif
+ wiz_show_vision, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+#if 0 /*JP:T*/
+ { '.', "wait", "rest one move while doing nothing",
+ donull, IFBURIED, "waiting" },
+#else
+ { '.', "wait", "\88ê\95à\95ª\89½\82à\82µ\82È\82¢",
+ donull, IFBURIED, "\8bx\8ce\82·\82é" },
+#endif
+ { 'W', "wear", "wear a piece of armor", dowear },
+ { '&', "whatdoes", "tell what a command does", dowhatdoes, IFBURIED },
+ { '/', "whatis", "show what type of thing a symbol corresponds to",
+ dowhatis, IFBURIED | GENERALCMD },
+ { 'w', "wield", "wield (put in use) a weapon", dowield },
+#if 0 /*JP:T*/
+ { M('w'), "wipe", "wipe off your face", dowipe, AUTOCOMPLETE },
+#else
+ { M('w'), "wipe", "\8aç\82ð\90@\82¤", dowipe, AUTOCOMPLETE },
+#endif
+#ifdef DEBUG
+#if 0 /*JP:T*/
+ { '\0', "wizbury", "bury objs under and around you",
+#else
+ { '\0', "wizbury", "\95¨\82ð\82 \82È\82½\82Ì\8eü\82è\82É\96\84\82ß\82é",
+#endif
+ wiz_debug_cmd_bury, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+#endif
+ { C('e'), "wizdetect", "reveal hidden things within a small radius",
+ wiz_detect, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+ { C('g'), "wizgenesis", "create a monster",
+ wiz_genesis, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+ { C('i'), "wizidentify", "identify all items in inventory",
+ wiz_identify, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+ { '\0', "wizintrinsic", "set an intrinsic",
+ wiz_intrinsic, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+ { C('v'), "wizlevelport", "teleport to another level",
+ wiz_level_tele, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+ { '\0', "wizmakemap", "recreate the current level",
+ wiz_makemap, IFBURIED | WIZMODECMD },
+ { C('f'), "wizmap", "map the level",
+ wiz_map, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+#if 0 /*JP:T*/
+ { '\0', "wizrumorcheck", "verify rumor boundaries",
+#else
+ { '\0', "wizrumorcheck", "\89\\82Ì\8b«\8aE\82ð\8c\9f\8fØ\82·\82é",
+#endif
+ wiz_rumor_check, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+#if 0 /*JP:T*/
+ { '\0', "wizsmell", "smell monster",
+#else
+ { '\0', "wizsmell", "\89ö\95¨\82Ì\93õ\82¢\82ð\9ak\82®",
+#endif
+ wiz_smell, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+ { '\0', "wizwhere", "show locations of special levels",
+ wiz_where, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+ { C('w'), "wizwish", "wish for something",
+ wiz_wish, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+#if 0 /*JP:T*/
+ { '\0', "wmode", "show wall modes",
+#else
+ { '\0', "wmode", "\95Ç\83\82\81[\83h\82ð\8c©\82é",
+#endif
+ wiz_show_wmodes, IFBURIED | AUTOCOMPLETE | WIZMODECMD },
+ { 'z', "zap", "zap a wand", dozap },
+ { '\0', (char *) 0, (char *) 0, donull, 0, (char *) 0 } /* sentinel */
+};
-static const struct func_tab cmdlist[] = {
- { C('d'), FALSE, dokick }, /* "D" is for door!...? Msg is in dokick.c */
- { C('e'), TRUE, wiz_detect },
- { C('f'), TRUE, wiz_map },
- { C('g'), TRUE, wiz_genesis },
- { C('i'), TRUE, wiz_identify },
- { C('l'), TRUE, doredraw }, /* if number_pad is set */
- { C('n'), TRUE, donamelevel }, /* if number_pad is set */
- { C('o'), TRUE, dooverview_or_wiz_where }, /* depends on wizard status */
- { C('p'), TRUE, doprev_message },
- { C('r'), TRUE, doredraw },
- { C('t'), TRUE, dotele },
- { C('v'), TRUE, wiz_level_tele },
- { C('w'), TRUE, wiz_wish },
- { C('x'), TRUE, doattributes },
- { C('z'), TRUE, dosuspend_core },
- { 'a', FALSE, doapply },
- { 'A', FALSE, doddoremarm },
- { M('a'), TRUE, doorganize },
- { M('A'), TRUE, donamelevel }, /* #annotate */
- /* 'b', 'B' : go sw */
- { 'c', FALSE, doclose },
- { 'C', TRUE, docallcmd },
- { M('c'), TRUE, dotalk },
- { M('C'), TRUE, doconduct }, /* #conduct */
- { 'd', FALSE, dodrop },
- { 'D', FALSE, doddrop },
- { M('d'), FALSE, dodip },
- { 'e', FALSE, doeat },
- { 'E', FALSE, doengrave },
- { M('e'), TRUE, enhance_weapon_skill },
- { 'f', FALSE, dofire },
- /* 'F' : fight (one time) */
- { M('f'), FALSE, doforce },
- /* 'g', 'G' : multiple go */
- /* 'h', 'H' : go west */
- { 'h', TRUE, dohelp }, /* if number_pad is set */
- { 'i', TRUE, ddoinv },
- { 'I', TRUE, dotypeinv }, /* Robert Viduya */
- { M('i'), TRUE, doinvoke },
- /* 'j', 'J', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N' : move commands */
- { 'j', FALSE, dojump }, /* if number_pad is on */
- { M('j'), FALSE, dojump },
- { 'k', FALSE, dokick }, /* if number_pad is on */
- { 'l', FALSE, doloot }, /* if number_pad is on */
- { M('l'), FALSE, doloot },
- /* 'n' prefixes a count if number_pad is on */
- { M('m'), TRUE, domonability },
- { 'N', TRUE, docallcmd }, /* if number_pad is on */
- { M('n'), TRUE, docallcmd },
- { M('N'), TRUE, docallcmd },
- { 'o', FALSE, doopen },
- { 'O', TRUE, doset },
- { M('o'), FALSE, dosacrifice },
- { M('O'), TRUE, dooverview }, /* #overview */
- { 'p', FALSE, dopay },
- { 'P', FALSE, doputon },
- { M('p'), TRUE, dopray },
- { 'q', FALSE, dodrink },
- { 'Q', FALSE, dowieldquiver },
- { M('q'), TRUE, done2 },
- { 'r', FALSE, doread },
- { 'R', FALSE, doremring },
- { M('r'), FALSE, dorub },
- { M('R'), FALSE, doride }, /* #ride */
-/*JP
- { 's', TRUE, dosearch, "searching" },
-*/
- { 's', TRUE, dosearch, "\91{\82·" },
- { 'S', TRUE, dosave },
- { M('s'), FALSE, dosit },
- { 't', FALSE, dothrow },
- { 'T', FALSE, dotakeoff },
- { M('t'), TRUE, doturn },
- { M('T'), FALSE, dotip }, /* #tip */
- /* 'u', 'U' : go ne */
- { 'u', FALSE, dountrap }, /* if number_pad is on */
- { M('u'), FALSE, dountrap },
- { 'v', TRUE, doversion },
- { 'V', TRUE, dohistory },
- { M('v'), TRUE, doextversion },
- { 'w', FALSE, dowield },
- { 'W', FALSE, dowear },
- { M('w'), FALSE, dowipe },
- { 'x', FALSE, doswapweapon },
- { 'X', FALSE, dotwoweapon },
- /* 'y', 'Y' : go nw */
- { 'z', FALSE, dozap },
- { 'Z', TRUE, docast },
- { '<', FALSE, doup },
- { '>', FALSE, dodown },
- { '/', TRUE, dowhatis },
- { '&', TRUE, dowhatdoes },
- { '?', TRUE, dohelp },
- { M('?'), TRUE, doextlist },
-#ifdef SHELL
- { '!', TRUE, dosh },
-#endif
-/*JP
- { '.', TRUE, donull, "waiting" },
-*/
- { '.', TRUE, donull, "\8bx\8ce\82·\82é" },
-/*JP
- { ' ', TRUE, donull, "waiting" },
-*/
- { ' ', TRUE, donull, "\8bx\8ce\82·\82é" },
- { ',', FALSE, dopickup },
- { ':', TRUE, dolook },
- { ';', TRUE, doquickwhatis },
- { '^', TRUE, doidtrap },
- { '\\', TRUE, dodiscovered }, /* Robert Viduya */
- { '`', TRUE, doclassdisco },
- { '@', TRUE, dotogglepickup },
- { M('2'), FALSE, dotwoweapon },
- { WEAPON_SYM, TRUE, doprwep },
- { ARMOR_SYM, TRUE, doprarm },
- { RING_SYM, TRUE, doprring },
- { AMULET_SYM, TRUE, dopramulet },
- { TOOL_SYM, TRUE, doprtool },
- { '*', TRUE, doprinuse }, /* inventory of all equipment in use */
- { GOLD_SYM, TRUE, doprgold },
- { SPBOOK_SYM, TRUE, dovspell }, /* Mike Stephenson */
- { '#', TRUE, doextcmd },
- { '_', TRUE, dotravel },
- { 0, 0, 0, 0 }
+/* for key2extcmddesc() to support dowhatdoes() */
+struct movcmd {
+ uchar k1, k2, k3, k4; /* 'normal', 'qwertz', 'numpad', 'phone' */
+ const char *txt, *alt; /* compass direction, screen direction */
+};
+static const struct movcmd movtab[] = {
+ { 'h', 'h', '4', '4', "west", "left" },
+ { 'j', 'j', '2', '8', "south", "down" },
+ { 'k', 'k', '8', '2', "north", "up" },
+ { 'l', 'l', '6', '6', "east", "right" },
+ { 'b', 'b', '1', '7', "southwest", "lower left" },
+ { 'n', 'n', '3', '9', "southeast", "lower right" },
+ { 'u', 'u', '9', '3', "northeast", "upper right" },
+ { 'y', 'z', '7', '1', "northwest", "upper left" },
+ { 0, 0, 0, 0, (char *) 0, (char *) 0 }
};
-struct ext_func_tab extcmdlist[] = {
+int extcmdlist_length = SIZE(extcmdlist) - 1;
+
+const char *
+key2extcmddesc(key)
+uchar key;
+{
+ static char key2cmdbuf[48];
+ const struct movcmd *mov;
+ int k, c;
+ uchar M_5 = (uchar) M('5'), M_0 = (uchar) M('0');
+
+ /* need to check for movement commands before checking the extended
+ commands table because it contains entries for number_pad commands
+ that match !number_pad movement (like 'j' for "jump") */
+ key2cmdbuf[0] = '\0';
+ if (movecmd(k = key))
+ Strcpy(key2cmdbuf, "move"); /* "move or attack"? */
+ else if (movecmd(k = unctrl(key)))
+ Strcpy(key2cmdbuf, "rush");
+ else if (movecmd(k = (Cmd.num_pad ? unmeta(key) : lowc(key))))
+ Strcpy(key2cmdbuf, "run");
+ if (*key2cmdbuf) {
+ for (mov = &movtab[0]; mov->k1; ++mov) {
+ c = !Cmd.num_pad ? (!Cmd.swap_yz ? mov->k1 : mov->k2)
+ : (!Cmd.phone_layout ? mov->k3 : mov->k4);
+ if (c == k) {
+ Sprintf(eos(key2cmdbuf), " %s (screen %s)",
+ mov->txt, mov->alt);
+ return key2cmdbuf;
+ }
+ }
+ } else if (digit(key) || (Cmd.num_pad && digit(unmeta(key)))) {
+ key2cmdbuf[0] = '\0';
+ if (!Cmd.num_pad)
+ Strcpy(key2cmdbuf, "start of, or continuation of, a count");
+ else if (key == '5' || key == M_5)
+ Sprintf(key2cmdbuf, "%s prefix",
+ (!!Cmd.pcHack_compat ^ (key == M_5)) ? "run" : "rush");
+ else if (key == '0' || (Cmd.pcHack_compat && key == M_0))
+ Strcpy(key2cmdbuf, "synonym for 'i'");
+ if (*key2cmdbuf)
+ return key2cmdbuf;
+ }
+ if (Cmd.commands[key]) {
+ if (Cmd.commands[key]->ef_txt)
+ return Cmd.commands[key]->ef_desc;
+
+ }
+ return (char *) 0;
+}
+
+boolean
+bind_key(key, command)
+uchar key;
+const char *command;
+{
+ struct ext_func_tab *extcmd;
+
+ /* special case: "nothing" is reserved for unbinding */
+ if (!strcmp(command, "nothing")) {
+ Cmd.commands[key] = (struct ext_func_tab *) 0;
+ return TRUE;
+ }
+
+ for (extcmd = extcmdlist; extcmd->ef_txt; extcmd++) {
+ if (strcmp(command, extcmd->ef_txt))
+ continue;
+ Cmd.commands[key] = extcmd;
+#if 0 /* silently accept key binding for unavailable command (!SHELL,&c) */
+ if ((extcmd->flags & CMD_NOT_AVAILABLE) != 0) {
+ char buf[BUFSZ];
+
+ Sprintf(buf, cmdnotavail, extcmd->ef_txt);
+ config_error_add("%s", buf);
+ }
+#endif
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+/* initialize all keyboard commands */
+void
+commands_init()
+{
+ struct ext_func_tab *extcmd;
+
+ for (extcmd = extcmdlist; extcmd->ef_txt; extcmd++)
+ if (extcmd->key)
+ Cmd.commands[extcmd->key] = extcmd;
+
+ (void) bind_key(C('l'), "redraw"); /* if number_pad is set */
+ /* 'b', 'B' : go sw */
+ /* 'F' : fight (one time) */
+ /* 'g', 'G' : multiple go */
+ /* 'h', 'H' : go west */
+ (void) bind_key('h', "help"); /* if number_pad is set */
+ (void) bind_key('j', "jump"); /* if number_pad is on */
+ /* 'j', 'J', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N' move commands */
+ (void) bind_key('k', "kick"); /* if number_pad is on */
+ (void) bind_key('l', "loot"); /* if number_pad is on */
+ (void) bind_key(C('n'), "annotate"); /* if number_pad is on */
+ (void) bind_key(M('n'), "name");
+ (void) bind_key(M('N'), "name");
+ (void) bind_key('u', "untrap"); /* if number_pad is on */
+
+ /* alt keys: */
+ (void) bind_key(M('O'), "overview");
+ (void) bind_key(M('2'), "twoweapon");
+
+ /* wait_on_space */
+ (void) bind_key(' ', "wait");
+}
+
+int
+dokeylist_putcmds(datawin, docount, cmdflags, exflags, keys_used)
+winid datawin;
+boolean docount;
+int cmdflags, exflags;
+boolean *keys_used; /* boolean keys_used[256] */
+{
+ int i;
+ char buf[BUFSZ];
+ char buf2[QBUFSZ];
+ int count = 0;
+
+ for (i = 0; i < 256; i++) {
+ const struct ext_func_tab *extcmd;
+ uchar key = (uchar) i;
+
+ if (keys_used[i])
+ continue;
+ if (key == ' ' && !flags.rest_on_space)
+ continue;
+ if ((extcmd = Cmd.commands[i]) != (struct ext_func_tab *) 0) {
+ if ((cmdflags && !(extcmd->flags & cmdflags))
+ || (exflags && (extcmd->flags & exflags)))
+ continue;
+ if (docount) {
+ count++;
+ continue;
+ }
+ Sprintf(buf, "%-8s %-12s %s", key2txt(key, buf2),
+ extcmd->ef_txt,
+ extcmd->ef_desc);
+ putstr(datawin, 0, buf);
+ keys_used[i] = TRUE;
+ }
+ }
+ return count;
+}
+
+/* list all keys and their bindings, like dat/hh but dynamic */
+void
+dokeylist(VOID_ARGS)
+{
+ char buf[BUFSZ], buf2[BUFSZ];
+ uchar key;
+ boolean keys_used[256] = {0};
+ winid datawin;
+ int i;
+ static const char
+ run_desc[] = "Prefix: run until something very interesting is seen",
+ forcefight_desc[] =
+ "Prefix: force fight even if you don't see a monster";
+ static const struct {
+ int nhkf;
+ const char *desc;
+ boolean numpad;
+ } misc_keys[] = {
+ { NHKF_ESC, "escape from the current query/action", FALSE },
+ { NHKF_RUSH,
+ "Prefix: rush until something interesting is seen", FALSE },
+ { NHKF_RUN, run_desc, FALSE },
+ { NHKF_RUN2, run_desc, TRUE },
+ { NHKF_FIGHT, forcefight_desc, FALSE },
+ { NHKF_FIGHT2, forcefight_desc, TRUE } ,
+ { NHKF_NOPICKUP,
+ "Prefix: move without picking up objects/fighting", FALSE },
+ { NHKF_RUN_NOPICKUP,
+ "Prefix: run without picking up objects/fighting", FALSE },
+ { NHKF_DOINV, "view inventory", TRUE },
+ { NHKF_REQMENU, "Prefix: request a menu", FALSE },
+#ifdef REDO
+ { NHKF_DOAGAIN , "re-do: perform the previous command again", FALSE },
+#endif
+ { 0, (const char *) 0, FALSE }
+ };
+
+ datawin = create_nhwindow(NHW_TEXT);
+ putstr(datawin, 0, "");
/*JP
- { "adjust", "adjust inventory letters", doorganize, TRUE },
+ putstr(datawin, 0, " Full Current Key Bindings List");
*/
- { "adjust", "\8e\9d\82¿\95¨\88ê\97\97\82Ì\92²\90®", doorganize, TRUE },
+ putstr(datawin, 0, " \8c»\8dÝ\82Ì\8a®\91S\82È\83L\81[\8a\84\82è\93\96\82Ä\88ê\97\97");
+
+ /* directional keys */
+ putstr(datawin, 0, "");
/*JP
- { "annotate", "name current level", donamelevel, TRUE },
+ putstr(datawin, 0, "Directional keys:");
*/
- { "annotate", "\8c»\8dÝ\82Ì\8aK\82É\96¼\91O\82ð\82Â\82¯\82é", donamelevel, TRUE },
-#if 0 /*JP*/
- { "chat", "talk to someone", dotalk, TRUE }, /* converse? */
+ putstr(datawin, 0, "\95û\8cü\83L\81[:");
+ show_direction_keys(datawin, '.', FALSE); /* '.'==self in direction grid */
+
+ keys_used[(uchar) Cmd.move_NW] = keys_used[(uchar) Cmd.move_N]
+ = keys_used[(uchar) Cmd.move_NE] = keys_used[(uchar) Cmd.move_W]
+ = keys_used[(uchar) Cmd.move_E] = keys_used[(uchar) Cmd.move_SW]
+ = keys_used[(uchar) Cmd.move_S] = keys_used[(uchar) Cmd.move_SE]
+ = TRUE;
+
+ if (!iflags.num_pad) {
+ keys_used[(uchar) highc(Cmd.move_NW)]
+ = keys_used[(uchar) highc(Cmd.move_N)]
+ = keys_used[(uchar) highc(Cmd.move_NE)]
+ = keys_used[(uchar) highc(Cmd.move_W)]
+ = keys_used[(uchar) highc(Cmd.move_E)]
+ = keys_used[(uchar) highc(Cmd.move_SW)]
+ = keys_used[(uchar) highc(Cmd.move_S)]
+ = keys_used[(uchar) highc(Cmd.move_SE)] = TRUE;
+ keys_used[(uchar) C(Cmd.move_NW)]
+ = keys_used[(uchar) C(Cmd.move_N)]
+ = keys_used[(uchar) C(Cmd.move_NE)]
+ = keys_used[(uchar) C(Cmd.move_W)]
+ = keys_used[(uchar) C(Cmd.move_E)]
+ = keys_used[(uchar) C(Cmd.move_SW)]
+ = keys_used[(uchar) C(Cmd.move_S)]
+ = keys_used[(uchar) C(Cmd.move_SE)] = TRUE;
+ putstr(datawin, 0, "");
+#if 0 /*JP:T*/
+ putstr(datawin, 0,
+ "Shift-<direction> will move in specified direction until you hit");
+ putstr(datawin, 0, " a wall or run into something.");
#else
- { "chat", "\92N\82©\82Æ\98b\82·", dotalk, TRUE }, /* converse? */
+ putstr(datawin, 0,
+ "Shift-<\95û\8cü> \82Í\81A\95Ç\82É\82Ô\82Â\82©\82é\82©\89½\82©\82ª\82 \82é\82Ü\82Å\8ew\92è\82³\82ê\82½\95û\8cü\82É");
+ putstr(datawin, 0, " \88Ú\93®\82·\82é\81D");
#endif
-#if 0 /*JP*/
- { "conduct", "list voluntary challenges you have maintained", doconduct,
- TRUE },
+#if 0 /*JP:T*/
+ putstr(datawin, 0,
+ "Ctrl-<direction> will run in specified direction until something");
+ putstr(datawin, 0, " very interesting is seen.");
#else
- { "conduct", "\82Ç\82¤\82¢\82¤\8ds\93®\82ð\82Æ\82Á\82½\82©\8c©\82é", doconduct, TRUE },
+ putstr(datawin, 0,
+ "Ctrl-<\95û\8cü> \82Í\81A\89½\82©\8b»\96¡\90[\82¢\82à\82Ì\82ª\8c©\82¦\82é\82Ü\82Å\8ew\92è\82³\82ê\82½\95û\8cü\82É");
+ putstr(datawin, 0, " \88Ú\93®\82·\82é\81D");
#endif
+ }
+
+ putstr(datawin, 0, "");
/*JP
- { "dip", "dip an object into something", dodip, FALSE },
+ putstr(datawin, 0, "Miscellaneous keys:");
*/
- { "dip", "\89½\82©\82É\95¨\82ð\90Z\82·", dodip, FALSE },
-#if 0 /*JP*/
- { "enhance", "advance or check weapon and spell skills",
- enhance_weapon_skill, TRUE },
-#else
- { "enhance", "\95\90\8aí\8fn\97û\93x\82ð\8d\82\82ß\82é", enhance_weapon_skill, TRUE },
+ putstr(datawin, 0, "\97l\81X\82È\83L\81[:");
+ for (i = 0; misc_keys[i].desc; i++) {
+ key = Cmd.spkeys[misc_keys[i].nhkf];
+ if (key && ((misc_keys[i].numpad && iflags.num_pad)
+ || !misc_keys[i].numpad)) {
+ keys_used[(uchar) key] = TRUE;
+ Sprintf(buf, "%-8s %s", key2txt(key, buf2), misc_keys[i].desc);
+ putstr(datawin, 0, buf);
+ }
+ }
+#ifndef NO_SIGNAL
+ putstr(datawin, 0, "^c break out of NetHack (SIGINT)");
+ keys_used[(uchar) C('c')] = TRUE;
#endif
+
+ putstr(datawin, 0, "");
+ show_menu_controls(datawin, TRUE);
+
+ if (dokeylist_putcmds(datawin, TRUE, GENERALCMD, WIZMODECMD, keys_used)) {
+ putstr(datawin, 0, "");
/*JP
- { "exploremode", "enter explore mode", enter_explore_mode, TRUE },
-*/
- { "exploremode", "\92T\8c\9f\83\82\81[\83h\82É\93ü\82é", enter_explore_mode, TRUE },
-/*JP
- { "force", "force a lock", doforce, FALSE },
-*/
- { "force", "\8c®\82ð\82±\82¶\82 \82¯\82é", doforce, FALSE },
-/*JP
- { "invoke", "invoke an object's powers", doinvoke, TRUE },
-*/
- { "invoke", "\95¨\82Ì\93Á\95Ê\82È\97Í\82ð\8eg\82¤", doinvoke, TRUE },
-/*JP
- { "jump", "jump to a location", dojump, FALSE },
-*/
- { "jump", "\91¼\82Ì\88Ê\92u\82É\94ò\82Ñ\82¤\82Â\82é", dojump, FALSE },
-/*JP
- { "loot", "loot a box on the floor", doloot, FALSE },
-*/
- { "loot", "\8f°\82Ì\8fã\82Ì\94 \82ð\8aJ\82¯\82é", doloot, TRUE },
-/*JP
- { "monster", "use a monster's special ability", domonability, TRUE },
-*/
- { "monster", "\89ö\95¨\82Ì\93Á\95Ê\94\\97Í\82ð\8eg\82¤", domonability, TRUE },
-/*JP
- { "name", "name a monster or an object", docallcmd, TRUE },
-*/
- { "name", "\83A\83C\83e\83\80\82â\95¨\82É\96¼\91O\82ð\82Â\82¯\82é", docallcmd, TRUE },
-/*JP
- { "offer", "offer a sacrifice to the gods", dosacrifice, FALSE },
-*/
- { "offer", "\90_\82É\8b\9f\95¨\82ð\95ù\82°\82é", dosacrifice, FALSE },
-/*JP
- { "overview", "show an overview of the dungeon", dooverview, TRUE },
-*/
- { "overview", "\96À\8b{\82Ì\8aT\97v\82ð\95\\8e¦\82·\82é", dooverview, TRUE },
-/*JP
- { "pray", "pray to the gods for help", dopray, TRUE },
-*/
- { "pray", "\90_\82É\8bF\82é", dopray, TRUE },
-/*JP
- { "quit", "exit without saving current game", done2, TRUE },
-*/
- { "quit", "\83Z\81[\83u\82µ\82È\82¢\82Å\8fI\97¹", done2, TRUE },
-/*JP
- { "ride", "ride (or stop riding) a monster", doride, FALSE },
-*/
- { "ride", "\89ö\95¨\82É\8fæ\82é(\82Ü\82½\82Í\8d~\82è\82é)", doride, FALSE },
-/*JP
- { "rub", "rub a lamp or a stone", dorub, FALSE },
-*/
- { "rub", "\83\89\83\93\83v\82ð\82±\82·\82é", dorub, FALSE },
-/*JP
- { "sit", "sit down", dosit, FALSE },
-*/
- { "sit", "\8dÀ\82é", dosit, FALSE },
-/*JP
- { "terrain", "show map without obstructions", doterrain, TRUE },
-*/
- { "terrain", "\8e×\96\82\82³\82ê\82¸\82É\92n\90}\82ð\8c©\82é", doterrain, TRUE },
-/*JP
- { "tip", "empty a container", dotip, FALSE },
-*/
- { "tip", "\93ü\82ê\95¨\82ð\8bó\82É\82·\82é", dotip, FALSE },
-/*JP
- { "turn", "turn undead", doturn, TRUE },
-*/
- { "turn", "\83A\83\93\83f\83b\83g\82ð\93y\82É\95Ô\82·", doturn, TRUE },
-/*JP
- { "twoweapon", "toggle two-weapon combat", dotwoweapon, FALSE },
-*/
- { "twoweapon", "\97¼\8eè\8e\9d\82¿\82Ì\90Ø\82è\91Ö\82¦", dotwoweapon, FALSE },
-/*JP
- { "untrap", "untrap something", dountrap, FALSE },
+ putstr(datawin, 0, "General commands:");
*/
- { "untrap", "ã©\82ð\82Í\82¸\82·", dountrap, FALSE },
-#if 0 /*JP*/
- { "version", "list compile time options for this version of NetHack",
- doextversion, TRUE },
-#else
- { "version", "\83R\83\93\83p\83C\83\8b\8e\9e\82Ì\83I\83v\83V\83\87\83\93\82ð\95\\8e¦\82·\82é", doextversion, TRUE },
-#endif
+ putstr(datawin, 0, "\88ê\94Ê\83R\83}\83\93\83h:");
+ (void) dokeylist_putcmds(datawin, FALSE, GENERALCMD, WIZMODECMD,
+ keys_used);
+ }
+
+ if (dokeylist_putcmds(datawin, TRUE, 0, WIZMODECMD, keys_used)) {
+ putstr(datawin, 0, "");
/*JP
- { "wipe", "wipe off your face", dowipe, FALSE },
+ putstr(datawin, 0, "Game commands:");
*/
- { "wipe", "\8aç\82ð\90@\82¤", dowipe, FALSE },
+ putstr(datawin, 0, "\83Q\81[\83\80\83R\83}\83\93\83h:");
+ (void) dokeylist_putcmds(datawin, FALSE, 0, WIZMODECMD, keys_used);
+ }
+
+ if (wizard
+ && dokeylist_putcmds(datawin, TRUE, WIZMODECMD, 0, keys_used)) {
+ putstr(datawin, 0, "");
/*JP
- { "?", "get this list of extended commands", doextlist, TRUE },
+ putstr(datawin, 0, "Wizard-mode commands:");
*/
- { "?", "\82±\82Ì\8ag\92£\83R\83}\83\93\83h\88ê\97\97\82ð\95\\8e¦\82·\82é", doextlist, TRUE },
- /*
- * There must be a blank entry here for every entry in the table
- * below.
- */
- { (char *) 0, (char *) 0, donull, TRUE }, /* levelchange */
- { (char *) 0, (char *) 0, donull, TRUE }, /* lightsources */
-#ifdef DEBUG_MIGRATING_MONS
- { (char *) 0, (char *) 0, donull, TRUE }, /* migratemons */
-#endif
- { (char *) 0, (char *) 0, donull, TRUE }, /* monpolycontrol */
- { (char *) 0, (char *) 0, donull, TRUE }, /* panic */
- { (char *) 0, (char *) 0, donull, TRUE }, /* polyself */
-#ifdef PORT_DEBUG
- { (char *) 0, (char *) 0, donull, TRUE }, /* portdebug */
-#endif
- { (char *) 0, (char *) 0, donull, TRUE }, /* seenv */
- { (char *) 0, (char *) 0, donull, TRUE }, /* stats */
- { (char *) 0, (char *) 0, donull, TRUE }, /* timeout */
- { (char *) 0, (char *) 0, donull, TRUE }, /* vanquished */
- { (char *) 0, (char *) 0, donull, TRUE }, /* vision */
- { (char *) 0, (char *) 0, donull, TRUE }, /* wizsmell */
-#ifdef DEBUG
- { (char *) 0, (char *) 0, donull, TRUE }, /* wizdebug_traveldisplay */
- { (char *) 0, (char *) 0, donull, TRUE }, /* wizdebug_bury */
-#endif
- { (char *) 0, (char *) 0, donull, TRUE }, /* wizrumorcheck */
- { (char *) 0, (char *) 0, donull, TRUE }, /* wmode */
- { (char *) 0, (char *) 0, donull, TRUE } /* sentinel */
-};
-
-/* there must be a placeholder in the table above for every entry here */
-static const struct ext_func_tab debug_extcmdlist[] = {
- { "levelchange", "change experience level", wiz_level_change, TRUE },
- { "lightsources", "show mobile light sources", wiz_light_sources, TRUE },
-#ifdef DEBUG_MIGRATING_MONS
- { "migratemons", "migrate n random monsters", wiz_migrate_mons, TRUE },
-#endif
- { "monpolycontrol", "control monster polymorphs", wiz_mon_polycontrol,
- TRUE },
- { "panic", "test panic routine (fatal to game)", wiz_panic, TRUE },
- { "polyself", "polymorph self", wiz_polyself, TRUE },
-#ifdef PORT_DEBUG
- { "portdebug", "wizard port debug command", wiz_port_debug, TRUE },
-#endif
- { "seenv", "show seen vectors", wiz_show_seenv, TRUE },
- { "stats", "show memory statistics", wiz_show_stats, TRUE },
- { "timeout", "look at timeout queue", wiz_timeout_queue, TRUE },
- { "vanquished", "list vanquished monsters", dovanquished, TRUE },
- { "vision", "show vision array", wiz_show_vision, TRUE },
- { "wizsmell", "smell monster", wiz_smell, TRUE },
-#ifdef DEBUG
- { "wizdebug_traveldisplay", "wizard debug: toggle travel display",
- wiz_debug_cmd_traveldisplay, TRUE },
- { "wizdebug_bury", "wizard debug: bury objs under and around you",
- wiz_debug_cmd_bury, TRUE },
-#endif
- { "wizrumorcheck", "verify rumor boundaries", wiz_rumor_check, TRUE },
- { "wmode", "show wall modes", wiz_show_wmodes, TRUE },
- { (char *) 0, (char *) 0, donull, TRUE }
-};
-
-/*
- * Insert debug commands into the extended command list. This function
- * assumes that the last entry will be the help entry.
- *
- * You must add entries in ext_func_tab every time you add one to the
- * debug_extcmdlist().
- */
-void
-add_debug_extended_commands()
-{
- int i, j, k, n;
-
- /* count the # of help entries */
- for (n = 0; extcmdlist[n].ef_txt[0] != '?'; n++)
- ;
-
- for (i = 0; debug_extcmdlist[i].ef_txt; i++) {
- /* need enough room for "?" entry plus terminator */
- if (n + 2 >= SIZE(extcmdlist))
- panic("Too many debugging commands!");
- for (j = 0; j < n; j++)
- if (strcmp(debug_extcmdlist[i].ef_txt, extcmdlist[j].ef_txt) < 0)
- break;
-
- /* insert i'th debug entry into extcmdlist[j], pushing down */
- for (k = n; k >= j; --k)
- extcmdlist[k + 1] = extcmdlist[k];
- extcmdlist[j] = debug_extcmdlist[i];
- n++; /* now an extra entry */
+ putstr(datawin, 0, "\83E\83B\83U\81[\83h\83\82\81[\83h\83R\83}\83\93\83h:");
+ (void) dokeylist_putcmds(datawin, FALSE, WIZMODECMD, 0, keys_used);
}
+
+ display_nhwindow(datawin, FALSE);
+ destroy_nhwindow(datawin);
}
-STATIC_OVL char
+char
cmd_from_func(fn)
int NDECL((*fn));
{
int i;
- for (i = 0; i < SIZE(cmdlist); ++i)
- if (cmdlist[i].f_funct == fn)
- return cmdlist[i].f_char;
- return 0;
+
+ for (i = 0; i < 256; ++i)
+ if (Cmd.commands[i] && Cmd.commands[i]->ef_funct == fn)
+ return (char) i;
+ return '\0';
}
-static const char template[] = "%-18s %4ld %6ld";
-static const char count_str[] = " count bytes";
-static const char separator[] = "------------------ ----- ------";
+/*
+ * wizard mode sanity_check code
+ */
+
+static const char template[] = "%-27s %4ld %6ld";
+static const char stats_hdr[] = " count bytes";
+static const char stats_sep[] = "--------------------------- ----- -------";
STATIC_OVL int
size_obj(otmp)
struct obj *otmp;
{
- int sz = (int) sizeof(struct obj);
+ int sz = (int) sizeof (struct obj);
if (otmp->oextra) {
- sz += (int) sizeof(struct oextra);
+ sz += (int) sizeof (struct oextra);
if (ONAME(otmp))
sz += (int) strlen(ONAME(otmp)) + 1;
if (OMONST(otmp))
- sz += (int) sizeof(struct monst);
+ sz += size_monst(OMONST(otmp), FALSE);
if (OMID(otmp))
- sz += (int) sizeof(unsigned);
+ sz += (int) sizeof (unsigned);
if (OLONG(otmp))
- sz += (int) sizeof(long);
+ sz += (int) sizeof (long);
if (OMAILCMD(otmp))
sz += (int) strlen(OMAILCMD(otmp)) + 1;
}
}
STATIC_OVL void
-obj_chain(win, src, chain, total_count, total_size)
+obj_chain(win, src, chain, force, total_count, total_size)
winid win;
const char *src;
struct obj *chain;
+boolean force;
long *total_count;
long *total_size;
{
char buf[BUFSZ];
- long count = 0, size = 0;
+ long count = 0L, size = 0L;
count_obj(chain, &count, &size, TRUE, FALSE);
- *total_count += count;
- *total_size += size;
- Sprintf(buf, template, src, count, size);
- putstr(win, 0, buf);
+
+ if (count || size || force) {
+ *total_count += count;
+ *total_size += size;
+ Sprintf(buf, template, src, count, size);
+ putstr(win, 0, buf);
+ }
}
STATIC_OVL void
for (mon = chain; mon; mon = mon->nmon)
count_obj(mon->minvent, &count, &size, TRUE, FALSE);
- *total_count += count;
- *total_size += size;
- Sprintf(buf, template, src, count, size);
- putstr(win, 0, buf);
+
+ if (count || size) {
+ *total_count += count;
+ *total_size += size;
+ Sprintf(buf, template, src, count, size);
+ putstr(win, 0, buf);
+ }
}
STATIC_OVL void
-contained(win, src, total_count, total_size)
+contained_stats(win, src, total_count, total_size)
winid win;
const char *src;
long *total_count;
for (mon = migrating_mons; mon; mon = mon->nmon)
count_obj(mon->minvent, &count, &size, FALSE, TRUE);
- *total_count += count;
- *total_size += size;
-
- Sprintf(buf, template, src, count, size);
- putstr(win, 0, buf);
+ if (count || size) {
+ *total_count += count;
+ *total_size += size;
+ Sprintf(buf, template, src, count, size);
+ putstr(win, 0, buf);
+ }
}
STATIC_OVL int
-size_monst(mtmp)
+size_monst(mtmp, incl_wsegs)
struct monst *mtmp;
+boolean incl_wsegs;
{
- int sz = (int) sizeof(struct monst);
+ int sz = (int) sizeof (struct monst);
+
+ if (mtmp->wormno && incl_wsegs)
+ sz += size_wseg(mtmp);
if (mtmp->mextra) {
- sz += (int) sizeof(struct mextra);
+ sz += (int) sizeof (struct mextra);
if (MNAME(mtmp))
sz += (int) strlen(MNAME(mtmp)) + 1;
if (EGD(mtmp))
- sz += (int) sizeof(struct egd);
+ sz += (int) sizeof (struct egd);
if (EPRI(mtmp))
- sz += (int) sizeof(struct epri);
+ sz += (int) sizeof (struct epri);
if (ESHK(mtmp))
- sz += (int) sizeof(struct eshk);
+ sz += (int) sizeof (struct eshk);
if (EMIN(mtmp))
- sz += (int) sizeof(struct emin);
+ sz += (int) sizeof (struct emin);
if (EDOG(mtmp))
- sz += (int) sizeof(struct edog);
+ sz += (int) sizeof (struct edog);
/* mextra->mcorpsenm doesn't point to more memory */
}
return sz;
}
STATIC_OVL void
-mon_chain(win, src, chain, total_count, total_size)
+mon_chain(win, src, chain, force, total_count, total_size)
winid win;
const char *src;
struct monst *chain;
+boolean force;
long *total_count;
long *total_size;
{
char buf[BUFSZ];
long count, size;
struct monst *mon;
+ /* mon->wormno means something different for migrating_mons and mydogs */
+ boolean incl_wsegs = !strcmpi(src, "fmon");
- for (count = size = 0, mon = chain; mon; mon = mon->nmon) {
+ count = size = 0L;
+ for (mon = chain; mon; mon = mon->nmon) {
count++;
- size += size_monst(mon);
+ size += size_monst(mon, incl_wsegs);
+ }
+ if (count || size || force) {
+ *total_count += count;
+ *total_size += size;
+ Sprintf(buf, template, src, count, size);
+ putstr(win, 0, buf);
+ }
+}
+
+STATIC_OVL void
+misc_stats(win, total_count, total_size)
+winid win;
+long *total_count;
+long *total_size;
+{
+ char buf[BUFSZ], hdrbuf[QBUFSZ];
+ long count, size;
+ int idx;
+ struct trap *tt;
+ struct damage *sd; /* shop damage */
+ struct kinfo *k; /* delayed killer */
+ struct cemetery *bi; /* bones info */
+
+ /* traps and engravings are output unconditionally;
+ * others only if nonzero
+ */
+ count = size = 0L;
+ for (tt = ftrap; tt; tt = tt->ntrap) {
+ ++count;
+ size += (long) sizeof *tt;
}
*total_count += count;
*total_size += size;
- Sprintf(buf, template, src, count, size);
+ Sprintf(hdrbuf, "traps, size %ld", (long) sizeof (struct trap));
+ Sprintf(buf, template, hdrbuf, count, size);
+ putstr(win, 0, buf);
+
+ count = size = 0L;
+ engr_stats("engravings, size %ld+text", hdrbuf, &count, &size);
+ *total_count += count;
+ *total_size += size;
+ Sprintf(buf, template, hdrbuf, count, size);
putstr(win, 0, buf);
+
+ count = size = 0L;
+ light_stats("light sources, size %ld", hdrbuf, &count, &size);
+ if (count || size) {
+ *total_count += count;
+ *total_size += size;
+ Sprintf(buf, template, hdrbuf, count, size);
+ putstr(win, 0, buf);
+ }
+
+ count = size = 0L;
+ timer_stats("timers, size %ld", hdrbuf, &count, &size);
+ if (count || size) {
+ *total_count += count;
+ *total_size += size;
+ Sprintf(buf, template, hdrbuf, count, size);
+ putstr(win, 0, buf);
+ }
+
+ count = size = 0L;
+ for (sd = level.damagelist; sd; sd = sd->next) {
+ ++count;
+ size += (long) sizeof *sd;
+ }
+ if (count || size) {
+ *total_count += count;
+ *total_size += size;
+ Sprintf(hdrbuf, "shop damage, size %ld",
+ (long) sizeof (struct damage));
+ Sprintf(buf, template, hdrbuf, count, size);
+ putstr(win, 0, buf);
+ }
+
+ count = size = 0L;
+ region_stats("regions, size %ld+%ld*rect+N", hdrbuf, &count, &size);
+ if (count || size) {
+ *total_count += count;
+ *total_size += size;
+ Sprintf(buf, template, hdrbuf, count, size);
+ putstr(win, 0, buf);
+ }
+
+ count = size = 0L;
+ for (k = killer.next; k; k = k->next) {
+ ++count;
+ size += (long) sizeof *k;
+ }
+ if (count || size) {
+ *total_count += count;
+ *total_size += size;
+ Sprintf(hdrbuf, "delayed killer%s, size %ld",
+ plur(count), (long) sizeof (struct kinfo));
+ Sprintf(buf, template, hdrbuf, count, size);
+ putstr(win, 0, buf);
+ }
+
+ count = size = 0L;
+ for (bi = level.bonesinfo; bi; bi = bi->next) {
+ ++count;
+ size += (long) sizeof *bi;
+ }
+ if (count || size) {
+ *total_count += count;
+ *total_size += size;
+ Sprintf(hdrbuf, "bones history, size %ld",
+ (long) sizeof (struct cemetery));
+ Sprintf(buf, template, hdrbuf, count, size);
+ putstr(win, 0, buf);
+ }
+
+ count = size = 0L;
+ for (idx = 0; idx < NUM_OBJECTS; ++idx)
+ if (objects[idx].oc_uname) {
+ ++count;
+ size += (long) (strlen(objects[idx].oc_uname) + 1);
+ }
+ if (count || size) {
+ *total_count += count;
+ *total_size += size;
+ Strcpy(hdrbuf, "object type names, text");
+ Sprintf(buf, template, hdrbuf, count, size);
+ putstr(win, 0, buf);
+ }
}
/*
{
char buf[BUFSZ];
winid win;
- long total_obj_size = 0, total_obj_count = 0;
- long total_mon_size = 0, total_mon_count = 0;
+ long total_obj_size, total_obj_count,
+ total_mon_size, total_mon_count,
+ total_ovr_size, total_ovr_count,
+ total_misc_size, total_misc_count;
win = create_nhwindow(NHW_TEXT);
putstr(win, 0, "Current memory statistics:");
- putstr(win, 0, "");
- Sprintf(buf, "Objects, size %d", (int) sizeof(struct obj));
+
+ total_obj_count = total_obj_size = 0L;
+ putstr(win, 0, stats_hdr);
+ Sprintf(buf, " Objects, base size %ld", (long) sizeof (struct obj));
putstr(win, 0, buf);
- putstr(win, 0, "");
- putstr(win, 0, count_str);
-
- obj_chain(win, "invent", invent, &total_obj_count, &total_obj_size);
- obj_chain(win, "fobj", fobj, &total_obj_count, &total_obj_size);
- obj_chain(win, "buried", level.buriedobjlist, &total_obj_count,
- &total_obj_size);
- obj_chain(win, "migrating obj", migrating_objs, &total_obj_count,
- &total_obj_size);
+ obj_chain(win, "invent", invent, TRUE, &total_obj_count, &total_obj_size);
+ obj_chain(win, "fobj", fobj, TRUE, &total_obj_count, &total_obj_size);
+ obj_chain(win, "buried", level.buriedobjlist, FALSE,
+ &total_obj_count, &total_obj_size);
+ obj_chain(win, "migrating obj", migrating_objs, FALSE,
+ &total_obj_count, &total_obj_size);
+ obj_chain(win, "billobjs", billobjs, FALSE,
+ &total_obj_count, &total_obj_size);
mon_invent_chain(win, "minvent", fmon, &total_obj_count, &total_obj_size);
mon_invent_chain(win, "migrating minvent", migrating_mons,
&total_obj_count, &total_obj_size);
-
- contained(win, "contained", &total_obj_count, &total_obj_size);
-
- putstr(win, 0, separator);
- Sprintf(buf, template, "Total", total_obj_count, total_obj_size);
+ contained_stats(win, "contained", &total_obj_count, &total_obj_size);
+ putstr(win, 0, stats_sep);
+ Sprintf(buf, template, " Obj total", total_obj_count, total_obj_size);
putstr(win, 0, buf);
+ total_mon_count = total_mon_size = 0L;
putstr(win, 0, "");
- putstr(win, 0, "");
- Sprintf(buf, "Monsters, size %d", (int) sizeof(struct monst));
+ Sprintf(buf, " Monsters, base size %ld", (long) sizeof (struct monst));
putstr(win, 0, buf);
+ mon_chain(win, "fmon", fmon, TRUE, &total_mon_count, &total_mon_size);
+ mon_chain(win, "migrating", migrating_mons, FALSE,
+ &total_mon_count, &total_mon_size);
+ /* 'mydogs' is only valid during level change or end of game disclosure,
+ but conceivably we've been called from within debugger at such time */
+ if (mydogs) /* monsters accompanying hero */
+ mon_chain(win, "mydogs", mydogs, FALSE,
+ &total_mon_count, &total_mon_size);
+ putstr(win, 0, stats_sep);
+ Sprintf(buf, template, " Mon total", total_mon_count, total_mon_size);
+ putstr(win, 0, buf);
+
+ total_ovr_count = total_ovr_size = 0L;
putstr(win, 0, "");
+ putstr(win, 0, " Overview");
+ overview_stats(win, template, &total_ovr_count, &total_ovr_size);
+ putstr(win, 0, stats_sep);
+ Sprintf(buf, template, " Over total", total_ovr_count, total_ovr_size);
+ putstr(win, 0, buf);
- mon_chain(win, "fmon", fmon, &total_mon_count, &total_mon_size);
- mon_chain(win, "migrating", migrating_mons, &total_mon_count,
- &total_mon_size);
+ total_misc_count = total_misc_size = 0L;
+ putstr(win, 0, "");
+ putstr(win, 0, " Miscellaneous");
+ misc_stats(win, &total_misc_count, &total_misc_size);
+ putstr(win, 0, stats_sep);
+ Sprintf(buf, template, " Misc total", total_misc_count, total_misc_size);
+ putstr(win, 0, buf);
- putstr(win, 0, separator);
- Sprintf(buf, template, "Total", total_mon_count, total_mon_size);
+ putstr(win, 0, "");
+ putstr(win, 0, stats_sep);
+ Sprintf(buf, template, " Grand total",
+ (total_obj_count + total_mon_count
+ + total_ovr_count + total_misc_count),
+ (total_obj_size + total_mon_size
+ + total_ovr_size + total_misc_size));
putstr(win, 0, buf);
#if defined(__BORLANDC__) && !defined(_WIN32)
timer_sanity_check();
mon_sanity_check();
light_sources_sanity_check();
+ bc_sanity_check();
}
#ifdef DEBUG_MIGRATING_MONS
wiz_migrate_mons()
{
int mcount = 0;
- char inbuf[BUFSZ];
+ char inbuf[BUFSZ] = DUMMY;
struct permonst *ptr;
struct monst *mtmp;
d_level tolevel;
}
#endif
-#define unctrl(c) ((c) <= C('z') ? (0x60 | (c)) : (c))
-#define unmeta(c) (0x7f & (c))
+struct {
+ int nhkf;
+ char key;
+ const char *name;
+} const spkeys_binds[] = {
+ { NHKF_ESC, '\033', (char *) 0 }, /* no binding */
+ { NHKF_DOAGAIN, DOAGAIN, "repeat" },
+ { NHKF_REQMENU, 'm', "reqmenu" },
+ { NHKF_RUN, 'G', "run" },
+ { NHKF_RUN2, '5', "run.numpad" },
+ { NHKF_RUSH, 'g', "rush" },
+ { NHKF_FIGHT, 'F', "fight" },
+ { NHKF_FIGHT2, '-', "fight.numpad" },
+ { NHKF_NOPICKUP, 'm', "nopickup" },
+ { NHKF_RUN_NOPICKUP, 'M', "run.nopickup" },
+ { NHKF_DOINV, '0', "doinv" },
+ { NHKF_TRAVEL, CMD_TRAVEL, (char *) 0 }, /* no binding */
+ { NHKF_CLICKLOOK, CMD_CLICKLOOK, (char *) 0 }, /* no binding */
+ { NHKF_REDRAW, C('r'), "redraw" },
+ { NHKF_REDRAW2, C('l'), "redraw.numpad" },
+ { NHKF_GETDIR_SELF, '.', "getdir.self" },
+ { NHKF_GETDIR_SELF2, 's', "getdir.self2" },
+ { NHKF_GETDIR_HELP, '?', "getdir.help" },
+ { NHKF_COUNT, 'n', "count" },
+ { NHKF_GETPOS_SELF, '@', "getpos.self" },
+ { NHKF_GETPOS_PICK, '.', "getpos.pick" },
+ { NHKF_GETPOS_PICK_Q, ',', "getpos.pick.quick" },
+ { NHKF_GETPOS_PICK_O, ';', "getpos.pick.once" },
+ { NHKF_GETPOS_PICK_V, ':', "getpos.pick.verbose" },
+ { NHKF_GETPOS_SHOWVALID, '$', "getpos.valid" },
+ { NHKF_GETPOS_AUTODESC, '#', "getpos.autodescribe" },
+ { NHKF_GETPOS_MON_NEXT, 'm', "getpos.mon.next" },
+ { NHKF_GETPOS_MON_PREV, 'M', "getpos.mon.prev" },
+ { NHKF_GETPOS_OBJ_NEXT, 'o', "getpos.obj.next" },
+ { NHKF_GETPOS_OBJ_PREV, 'O', "getpos.obj.prev" },
+ { NHKF_GETPOS_DOOR_NEXT, 'd', "getpos.door.next" },
+ { NHKF_GETPOS_DOOR_PREV, 'D', "getpos.door.prev" },
+ { NHKF_GETPOS_UNEX_NEXT, 'x', "getpos.unexplored.next" },
+ { NHKF_GETPOS_UNEX_PREV, 'X', "getpos.unexplored.prev" },
+ { NHKF_GETPOS_VALID_NEXT, 'z', "getpos.valid.next" },
+ { NHKF_GETPOS_VALID_PREV, 'Z', "getpos.valid.prev" },
+ { NHKF_GETPOS_INTERESTING_NEXT, 'a', "getpos.all.next" },
+ { NHKF_GETPOS_INTERESTING_PREV, 'A', "getpos.all.prev" },
+ { NHKF_GETPOS_HELP, '?', "getpos.help" },
+ { NHKF_GETPOS_LIMITVIEW, '"', "getpos.filter" },
+ { NHKF_GETPOS_MOVESKIP, '*', "getpos.moveskip" },
+ { NHKF_GETPOS_MENU, '!', "getpos.menu" }
+};
+
+boolean
+bind_specialkey(key, command)
+uchar key;
+const char *command;
+{
+ int i;
+ for (i = 0; i < SIZE(spkeys_binds); i++) {
+ if (!spkeys_binds[i].name || strcmp(command, spkeys_binds[i].name))
+ continue;
+ Cmd.spkeys[spkeys_binds[i].nhkf] = key;
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/* returns a one-byte character from the text (it may massacre the txt
+ * buffer) */
+char
+txt2key(txt)
+char *txt;
+{
+ txt = trimspaces(txt);
+ if (!*txt)
+ return '\0';
+
+ /* simple character */
+ if (!txt[1])
+ return txt[0];
+
+ /* a few special entries */
+ if (!strcmp(txt, "<enter>"))
+ return '\n';
+ if (!strcmp(txt, "<space>"))
+ return ' ';
+ if (!strcmp(txt, "<esc>"))
+ return '\033';
+
+ /* control and meta keys */
+ switch (*txt) {
+ case 'm': /* can be mx, Mx, m-x, M-x */
+ case 'M':
+ txt++;
+ if (*txt == '-' && txt[1])
+ txt++;
+ if (txt[1])
+ return '\0';
+ return M(*txt);
+ case 'c': /* can be cx, Cx, ^x, c-x, C-x, ^-x */
+ case 'C':
+ case '^':
+ txt++;
+ if (*txt == '-' && txt[1])
+ txt++;
+ if (txt[1])
+ return '\0';
+ return C(*txt);
+ }
+
+ /* ascii codes: must be three-digit decimal */
+ if (*txt >= '0' && *txt <= '9') {
+ uchar key = 0;
+ int i;
+
+ for (i = 0; i < 3; i++) {
+ if (txt[i] < '0' || txt[i] > '9')
+ return '\0';
+ key = 10 * key + txt[i] - '0';
+ }
+ return key;
+ }
+
+ return '\0';
+}
+
+/* returns the text for a one-byte encoding;
+ * must be shorter than a tab for proper formatting */
+char *
+key2txt(c, txt)
+uchar c;
+char *txt; /* sufficiently long buffer */
+{
+ /* should probably switch to "SPC", "ESC", "RET"
+ since nethack's documentation uses ESC for <escape> */
+ if (c == ' ')
+ Sprintf(txt, "<space>");
+ else if (c == '\033')
+ Sprintf(txt, "<esc>");
+ else if (c == '\n')
+ Sprintf(txt, "<enter>");
+ else if (c == '\177')
+ Sprintf(txt, "<del>"); /* "<delete>" won't fit */
+ else
+ Strcpy(txt, visctrl((char) c));
+ return txt;
+}
+
+
+void
+parseautocomplete(autocomplete, condition)
+char *autocomplete;
+boolean condition;
+{
+ struct ext_func_tab *efp;
+ register char *autoc;
+
+ /* break off first autocomplete from the rest; parse the rest */
+ if ((autoc = index(autocomplete, ',')) != 0
+ || (autoc = index(autocomplete, ':')) != 0) {
+ *autoc++ = '\0';
+ parseautocomplete(autoc, condition);
+ }
+
+ /* strip leading and trailing white space */
+ autocomplete = trimspaces(autocomplete);
+
+ if (!*autocomplete)
+ return;
+
+ /* take off negation */
+ if (*autocomplete == '!') {
+ /* unlike most options, a leading "no" might actually be a part of
+ * the extended command. Thus you have to use ! */
+ autocomplete++;
+ autocomplete = trimspaces(autocomplete);
+ condition = !condition;
+ }
+
+ /* find and modify the extended command */
+ for (efp = extcmdlist; efp->ef_txt; efp++) {
+ if (!strcmp(autocomplete, efp->ef_txt)) {
+ if (condition)
+ efp->flags |= AUTOCOMPLETE;
+ else
+ efp->flags &= ~AUTOCOMPLETE;
+ return;
+ }
+ }
+
+ /* not a real extended command */
+ raw_printf("Bad autocomplete: invalid extended command '%s'.",
+ autocomplete);
+ wait_synch();
+}
/* called at startup and after number_pad is twiddled */
void
static const int ylist[] = {
'y', 'Y', C('y'), M('y'), M('Y'), M(C('y'))
};
- const struct func_tab *cmdtmp;
+ static struct ext_func_tab *back_dir_cmd[8];
+ const struct ext_func_tab *cmdtmp;
boolean flagtemp;
int c, i, updated = 0;
+ static boolean backed_dir_cmd = FALSE;
if (initial) {
updated = 1;
- for (i = 0; i < SIZE(cmdlist); i++) {
- c = cmdlist[i].f_char & 0xff;
- Cmd.commands[c] = &cmdlist[i];
- }
Cmd.num_pad = FALSE;
Cmd.pcHack_compat = Cmd.phone_layout = Cmd.swap_yz = FALSE;
+ for (i = 0; i < SIZE(spkeys_binds); i++)
+ Cmd.spkeys[spkeys_binds[i].nhkf] = spkeys_binds[i].key;
+ commands_init();
} else {
+
+ if (backed_dir_cmd) {
+ for (i = 0; i < 8; i++) {
+ Cmd.commands[(uchar) Cmd.dirchars[i]] = back_dir_cmd[i];
+ }
+ }
+
/* basic num_pad */
flagtemp = iflags.num_pad;
if (flagtemp != Cmd.num_pad) {
Cmd.num_pad = flagtemp;
++updated;
}
- /* swap_yz mode (only applicable for !num_pad) */
+ /* swap_yz mode (only applicable for !num_pad); intended for
+ QWERTZ keyboard used in Central Europe, particularly Germany */
flagtemp = (iflags.num_pad_mode & 1) ? !Cmd.num_pad : FALSE;
if (flagtemp != Cmd.swap_yz) {
Cmd.swap_yz = flagtemp;
++updated;
/* phone_layout has been toggled */
for (i = 0; i < 3; i++) {
- c = '1' + i; /* 1,2,3 <-> 7,8,9 */
+ c = '1' + i; /* 1,2,3 <-> 7,8,9 */
cmdtmp = Cmd.commands[c]; /* tmp = [1] */
Cmd.commands[c] = Cmd.commands[c + 6]; /* [1] = [7] */
Cmd.commands[c + 6] = cmdtmp; /* [7] = tmp */
- c = (M('1') & 0xff) + i; /* M-1,M-2,M-3 <-> M-7,M-8,M-9 */
- cmdtmp = Cmd.commands[c]; /* tmp = [M-1] */
+ c = (M('1') & 0xff) + i; /* M-1,M-2,M-3 <-> M-7,M-8,M-9 */
+ cmdtmp = Cmd.commands[c]; /* tmp = [M-1] */
Cmd.commands[c] = Cmd.commands[c + 6]; /* [M-1] = [M-7] */
Cmd.commands[c + 6] = cmdtmp; /* [M-7] = tmp */
}
Cmd.move_SE = Cmd.dirchars[5];
Cmd.move_S = Cmd.dirchars[6];
Cmd.move_SW = Cmd.dirchars[7];
+
+ if (!initial) {
+ for (i = 0; i < 8; i++) {
+ back_dir_cmd[i] =
+ (struct ext_func_tab *) Cmd.commands[(uchar) Cmd.dirchars[i]];
+ Cmd.commands[(uchar) Cmd.dirchars[i]] = (struct ext_func_tab *) 0;
+ }
+ backed_dir_cmd = TRUE;
+ for (i = 0; i < 8; i++)
+ (void) bind_key(Cmd.dirchars[i], "nothing");
+ }
}
+/* non-movement commands which accept 'm' prefix to request menu operation */
STATIC_OVL boolean
accept_menu_prefix(cmd_func)
int NDECL((*cmd_func));
{
if (cmd_func == dopickup || cmd_func == dotip
+ /* eat, #offer, and apply tinning-kit all use floorfood() to pick
+ an item on floor or in invent; 'm' skips picking from floor
+ (ie, inventory only) rather than request use of menu operation */
+ || cmd_func == doeat || cmd_func == dosacrifice || cmd_func == doapply
+ /* 'm' for removing saddle from adjacent monster without checking
+ for containers at <u.ux,u.uy> */
+ || cmd_func == doloot
+ /* travel: pop up a menu of interesting targets in view */
+ || cmd_func == dotravel
+ /* wizard mode ^V and ^T */
+ || cmd_func == wiz_level_tele || cmd_func == dotelecmd
+ /* 'm' prefix allowed for some extended commands */
|| cmd_func == doextcmd || cmd_func == doextlist)
return TRUE;
return FALSE;
}
+char
+randomkey()
+{
+ static unsigned i = 0;
+ char c;
+
+ switch (rn2(16)) {
+ default:
+ c = '\033';
+ break;
+ case 0:
+ c = '\n';
+ break;
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ c = (char) rn1('~' - ' ' + 1, ' ');
+ break;
+ case 5:
+ c = (char) (rn2(2) ? '\t' : ' ');
+ break;
+ case 6:
+ c = (char) rn1('z' - 'a' + 1, 'a');
+ break;
+ case 7:
+ c = (char) rn1('Z' - 'A' + 1, 'A');
+ break;
+ case 8:
+ c = extcmdlist[i++ % SIZE(extcmdlist)].key;
+ break;
+ case 9:
+ c = '#';
+ break;
+ case 10:
+ case 11:
+ case 12:
+ c = Cmd.dirchars[rn2(8)];
+ if (!rn2(7))
+ c = !Cmd.num_pad ? (!rn2(3) ? C(c) : (c + 'A' - 'a')) : M(c);
+ break;
+ case 13:
+ c = (char) rn1('9' - '0' + 1, '0');
+ break;
+ case 14:
+ /* any char, but avoid '\0' because it's used for mouse click */
+ c = (char) rnd(iflags.wc_eight_bit_input ? 255 : 127);
+ break;
+ }
+
+ return c;
+}
+
+void
+random_response(buf, sz)
+char *buf;
+int sz;
+{
+ char c;
+ int count = 0;
+
+ for (;;) {
+ c = randomkey();
+ if (c == '\n')
+ break;
+ if (c == '\033') {
+ count = 0;
+ break;
+ }
+ if (count < sz - 1)
+ buf[count++] = c;
+ }
+ buf[count] = '\0';
+}
+
+int
+rnd_extcmd_idx(VOID_ARGS)
+{
+ return rn2(extcmdlist_length + 1) - 1;
+}
+
+int
+ch2spkeys(c, start, end)
+char c;
+int start,end;
+{
+ int i;
+
+ for (i = start; i <= end; i++)
+ if (Cmd.spkeys[i] == c)
+ return i;
+ return NHKF_ESC;
+}
+
void
rhack(cmd)
register char *cmd;
{
- boolean do_walk, do_rush, prefix_seen, bad_command,
+ int spkey;
+ boolean prefix_seen, bad_command,
firsttime = (cmd == 0);
iflags.menu_requested = FALSE;
context.nopick = 0;
cmd = parse();
}
- if (*cmd == '\033') {
+ if (*cmd == Cmd.spkeys[NHKF_ESC]) {
context.move = FALSE;
return;
}
}
/* handle most movement commands */
- do_walk = do_rush = prefix_seen = FALSE;
+ prefix_seen = FALSE;
context.travel = context.travel1 = 0;
- switch (*cmd) {
- case 'g':
+ spkey = ch2spkeys(*cmd, NHKF_RUN, NHKF_CLICKLOOK);
+
+ switch (spkey) {
+ case NHKF_RUSH:
if (movecmd(cmd[1])) {
context.run = 2;
- do_rush = TRUE;
+ domove_attempting |= DOMOVE_RUSH;
} else
prefix_seen = TRUE;
break;
- case '5':
+ case NHKF_RUN2:
if (!Cmd.num_pad)
- break; /* else FALLTHRU */
- case 'G':
+ break;
+ /*FALLTHRU*/
+ case NHKF_RUN:
if (movecmd(lowc(cmd[1]))) {
context.run = 3;
- do_rush = TRUE;
+ domove_attempting |= DOMOVE_RUSH;
} else
prefix_seen = TRUE;
break;
- case '-':
+ case NHKF_FIGHT2:
if (!Cmd.num_pad)
- break; /* else FALLTHRU */
+ break;
+ /*FALLTHRU*/
/* Effects of movement commands and invisible monsters:
* m: always move onto space (even if 'I' remembered)
* F: always attack space (even if 'I' not remembered)
* normal movement: attack if 'I', move otherwise.
*/
- case 'F':
+ case NHKF_FIGHT:
if (movecmd(cmd[1])) {
context.forcefight = 1;
- do_walk = TRUE;
+ domove_attempting |= DOMOVE_WALK;
} else
prefix_seen = TRUE;
break;
- case 'm':
+ case NHKF_NOPICKUP:
if (movecmd(cmd[1]) || u.dz) {
context.run = 0;
context.nopick = 1;
if (!u.dz)
- do_walk = TRUE;
+ domove_attempting |= DOMOVE_WALK;
else
cmd[0] = cmd[1]; /* "m<" or "m>" */
} else
prefix_seen = TRUE;
break;
- case 'M':
+ case NHKF_RUN_NOPICKUP:
if (movecmd(lowc(cmd[1]))) {
context.run = 1;
context.nopick = 1;
- do_rush = TRUE;
+ domove_attempting |= DOMOVE_RUSH;
} else
prefix_seen = TRUE;
break;
- case '0':
+ case NHKF_DOINV:
if (!Cmd.num_pad)
break;
(void) ddoinv(); /* a convenience borrowed from the PC */
context.move = FALSE;
multi = 0;
return;
- case CMD_CLICKLOOK:
+ case NHKF_CLICKLOOK:
if (iflags.clicklook) {
context.move = FALSE;
do_look(2, &clicklook_cc);
}
return;
- case CMD_TRAVEL:
+ case NHKF_TRAVEL:
if (flags.travelcmd) {
context.travel = 1;
context.travel1 = 1;
context.run = 8;
context.nopick = 1;
- do_rush = TRUE;
+ domove_attempting |= DOMOVE_RUSH;
break;
}
/*FALLTHRU*/
default:
if (movecmd(*cmd)) { /* ordinary movement */
context.run = 0; /* only matters here if it was 8 */
- do_walk = TRUE;
+ domove_attempting |= DOMOVE_WALK;
} else if (movecmd(Cmd.num_pad ? unmeta(*cmd) : lowc(*cmd))) {
context.run = 1;
- do_rush = TRUE;
+ domove_attempting |= DOMOVE_RUSH;
} else if (movecmd(unctrl(*cmd))) {
context.run = 3;
- do_rush = TRUE;
+ domove_attempting |= DOMOVE_RUSH;
}
break;
}
/* some special prefix handling */
/* overload 'm' prefix to mean "request a menu" */
- if (prefix_seen && cmd[0] == 'm') {
+ if (prefix_seen && cmd[0] == Cmd.spkeys[NHKF_REQMENU]) {
/* (for func_tab cast, see below) */
- const struct func_tab *ft = Cmd.commands[cmd[1] & 0xff];
- int NDECL((*func)) = ft ? ((struct func_tab *) ft)->f_funct : 0;
+ const struct ext_func_tab *ft = Cmd.commands[cmd[1] & 0xff];
+ int NDECL((*func)) = ft ? ((struct ext_func_tab *) ft)->ef_funct : 0;
if (func && accept_menu_prefix(func)) {
iflags.menu_requested = TRUE;
}
}
- if ((do_walk || do_rush) && !context.travel && !dxdy_moveok()) {
+ if (((domove_attempting & (DOMOVE_RUSH | DOMOVE_WALK)) != 0L)
+ && !context.travel && !dxdy_moveok()) {
/* trying to move diagonally as a grid bug;
this used to be treated by movecmd() as not being
a movement attempt, but that didn't provide for any
feedback and led to strangeness if the key pressed
('u' in particular) was overloaded for num_pad use */
+/*JP
You_cant("get there from here...");
+*/
+ You_cant("\82±\82±\82©\82ç\82»\82±\82Ö\82Í\8ds\82¯\82Ü\82¹\82ñ\81D\81D\81D");
context.run = 0;
context.nopick = context.forcefight = FALSE;
context.move = context.mv = FALSE;
return;
}
- if (do_walk) {
+ if ((domove_attempting & DOMOVE_WALK) != 0L) {
if (multi)
context.mv = TRUE;
domove();
context.forcefight = 0;
return;
- } else if (do_rush) {
+ } else if ((domove_attempting & DOMOVE_RUSH) != 0L) {
if (firsttime) {
if (!multi)
multi = max(COLNO, ROWNO);
context.mv = TRUE;
domove();
return;
- } else if (prefix_seen && cmd[1] == '\033') { /* <prefix><escape> */
+ } else if (prefix_seen && cmd[1] == Cmd.spkeys[NHKF_ESC]) {
+ /* <prefix><escape> */
/* don't report "unknown command" for change of heart... */
bad_command = FALSE;
} else if (*cmd == ' ' && !flags.rest_on_space) {
bad_command = TRUE; /* skip cmdlist[] loop */
- /* handle all other commands */
+ /* handle all other commands */
} else {
- register const struct func_tab *tlist;
+ register const struct ext_func_tab *tlist;
int res, NDECL((*func));
-#if 0
- /* obsolete - scan through the cmdlist array looking for *cmd */
- for (tlist = cmdlist; tlist->f_char; tlist++) {
- if ((*cmd & 0xff) != (tlist->f_char & 0xff))
- continue;
-#else
/* current - use *cmd to directly index cmdlist array */
if ((tlist = Cmd.commands[*cmd & 0xff]) != 0) {
-#endif
- if (u.uburied && !tlist->can_if_buried) {
+ if (!wizard && (tlist->flags & WIZMODECMD)) {
+/*JP
+ You_cant("do that!");
+*/
+ pline("\82»\82ê\82Í\82Å\82«\82Ü\82¹\82ñ\81I");
+ res = 0;
+ } else if (u.uburied && !(tlist->flags & IFBURIED)) {
/*JP
You_cant("do that while you are buried!");
*/
} else {
/* we discard 'const' because some compilers seem to have
trouble with the pointer passed to set_occupation() */
- func = ((struct func_tab *) tlist)->f_funct;
+ func = ((struct ext_func_tab *) tlist)->ef_funct;
if (tlist->f_text && !occupation && multi)
set_occupation(func, tlist->f_text, multi);
res = (*func)(); /* perform the command */
}
if (bad_command) {
- char expcmd[10];
- register char c, *cp = expcmd;
-
- while ((c = *cmd++) != '\0'
- && (int) (cp - expcmd) < (int) (sizeof expcmd - 3)) {
- if (c >= 040 && c < 0177) {
- *cp++ = c;
- } else if (c & 0200) {
- *cp++ = 'M';
- *cp++ = '-';
- *cp++ = c & ~0200;
- } else {
- *cp++ = '^';
- *cp++ = c ^ 0100;
- }
- }
- *cp = '\0';
- if (!prefix_seen || !iflags.cmdassist
+ char expcmd[20]; /* we expect 'cmd' to point to 1 or 2 chars */
+ char c, c1 = cmd[1];
+
+ expcmd[0] = '\0';
+ while ((c = *cmd++) != '\0')
+ Strcat(expcmd, visctrl(c)); /* add 1..4 chars plus terminator */
+
/*JP
- || !help_dir(0, "Invalid direction key!"))
+ if (!prefix_seen || !help_dir(c1, spkey, "Invalid direction key!"))
*/
- || !help_dir(0, "\96³\8cø\82È\95û\8cü\8ew\92è\82Å\82·\81I"))
+ if (!prefix_seen || !help_dir(c1, spkey, "\96³\8cø\82È\95û\8cü\8ew\92è\82Å\82·\81I"))
/*JP
Norep("Unknown command '%s'.", expcmd);
*/
redraw_cmd(c)
char c;
{
- return (boolean) (c == C('r') || (Cmd.num_pad && c == C('l')));
+ return (boolean) (c == Cmd.spkeys[NHKF_REDRAW]
+ || (Cmd.num_pad && c == Cmd.spkeys[NHKF_REDRAW2]));
+}
+
+boolean
+prefix_cmd(c)
+char c;
+{
+ return (c == Cmd.spkeys[NHKF_RUSH]
+ || c == Cmd.spkeys[NHKF_RUN]
+ || c == Cmd.spkeys[NHKF_NOPICKUP]
+ || c == Cmd.spkeys[NHKF_RUN_NOPICKUP]
+ || c == Cmd.spkeys[NHKF_FIGHT]
+ || (Cmd.num_pad && (c == Cmd.spkeys[NHKF_RUN2]
+ || c == Cmd.spkeys[NHKF_FIGHT2])));
}
/*
char dirsym;
int is_mov;
-retry:
+ retry:
if (in_doagain || *readchar_queue)
dirsym = readchar();
else
}
savech(dirsym);
- if (dirsym == '.' || dirsym == 's') {
+ if (dirsym == Cmd.spkeys[NHKF_GETDIR_SELF]
+ || dirsym == Cmd.spkeys[NHKF_GETDIR_SELF2]) {
u.dx = u.dy = u.dz = 0;
} else if (!(is_mov = movecmd(dirsym)) && !u.dz) {
boolean did_help = FALSE, help_requested;
- if (!index(quitchars, dirsym)) {
- help_requested = (dirsym == '?');
- if (help_requested || iflags.cmdassist) {
- did_help =
- help_dir((s && *s == '^') ? dirsym : 0,
- help_requested ? (const char *) 0
-/*JP
- : "Invalid direction key!");
-*/
- : "\96³\8cø\82È\95û\8cü\8ew\92è\82Å\82·\81I");
- if (help_requested)
- goto retry;
- }
- if (!did_help)
-/*JP
- pline("What a strange direction!");
-*/
- pline("\82¸\82¢\82Ô\82ñ\82Æ\8aï\96\82È\95û\8cü\82¾\81I");
- }
- return 0;
- } else if (is_mov && !dxdy_moveok()) {
+ if (!index(quitchars, dirsym)) {
+ help_requested = (dirsym == Cmd.spkeys[NHKF_GETDIR_HELP]);
+ if (help_requested || iflags.cmdassist) {
+ did_help = help_dir((s && *s == '^') ? dirsym : '\0',
+ NHKF_ESC,
+ help_requested ? (const char *) 0
+/*JP
+ : "Invalid direction key!");
+*/
+ : "\96³\8cø\82È\95û\8cü\8ew\92è\82Å\82·\81I");
+ if (help_requested)
+ goto retry;
+ }
+ if (!did_help)
+/*JP
+ pline("What a strange direction!");
+*/
+ pline("\82¸\82¢\82Ô\82ñ\82Æ\8aï\96\82È\95û\8cü\82¾\81I");
+ }
+ return 0;
+ } else if (is_mov && !dxdy_moveok()) {
+/*JP
+ You_cant("orient yourself that direction.");
+*/
+ You_cant("\8cü\82«\82É\8e©\95ª\8e©\90g\82ð\8ew\92è\82Å\82«\82È\82¢\81D");
+ return 0;
+ }
+ if (!u.dz && (Stunned || (Confusion && !rn2(5))))
+ confdir();
+ return 1;
+}
+
+STATIC_OVL void
+show_direction_keys(win, centerchar, nodiag)
+winid win; /* should specify a window which is using a fixed-width font... */
+char centerchar; /* '.' or '@' or ' ' */
+boolean nodiag;
+{
+ char buf[BUFSZ];
+
+ if (!centerchar)
+ centerchar = ' ';
+
+ if (nodiag) {
+ Sprintf(buf, " %c ", Cmd.move_N);
+ putstr(win, 0, buf);
+ putstr(win, 0, " | ");
+ Sprintf(buf, " %c- %c -%c",
+ Cmd.move_W, centerchar, Cmd.move_E);
+ putstr(win, 0, buf);
+ putstr(win, 0, " | ");
+ Sprintf(buf, " %c ", Cmd.move_S);
+ putstr(win, 0, buf);
+ } else {
+ Sprintf(buf, " %c %c %c",
+ Cmd.move_NW, Cmd.move_N, Cmd.move_NE);
+ putstr(win, 0, buf);
+ putstr(win, 0, " \\ | / ");
+ Sprintf(buf, " %c- %c -%c",
+ Cmd.move_W, centerchar, Cmd.move_E);
+ putstr(win, 0, buf);
+ putstr(win, 0, " / | \\ ");
+ Sprintf(buf, " %c %c %c",
+ Cmd.move_SW, Cmd.move_S, Cmd.move_SE);
+ putstr(win, 0, buf);
+ };
+}
+
+/* explain choices if player has asked for getdir() help or has given
+ an invalid direction after a prefix key ('F', 'g', 'm', &c), which
+ might be bogus but could be up, down, or self when not applicable */
+STATIC_OVL boolean
+help_dir(sym, spkey, msg)
+char sym;
+int spkey; /* NHKF_ code for prefix key, if one was used, or for ESC */
+const char *msg;
+{
+ static const char wiz_only_list[] = "EFGIVW";
+ char ctrl;
+ winid win;
+ char buf[BUFSZ], buf2[BUFSZ], *explain;
+ const char *dothat, *how;
+ boolean prefixhandling, viawindow;
+
+ /* NHKF_ESC indicates that player asked for help at getdir prompt */
+ viawindow = (spkey == NHKF_ESC || iflags.cmdassist);
+ prefixhandling = (spkey != NHKF_ESC);
+ /*
+ * Handling for prefix keys that don't want special directions.
+ * Delivered via pline if 'cmdassist' is off, or instead of the
+ * general message if it's on.
+ */
+ dothat = "do that";
+#if 0 /*JP*/
+ how = " at"; /* for "<action> at yourself"; not used for up/down */
+#else
+ how = "";
+#endif
+ switch (spkey) {
+ case NHKF_NOPICKUP:
+#if 0 /*JP*/
+ dothat = "move";
+#else
+ dothat = "\88Ú\93®\82·\82é";
+#endif
+ break;
+ case NHKF_RUSH:
+#if 0 /*JP*/
+ dothat = "rush";
+#else
+ dothat = "\93Ë\90i\82·\82é";
+#endif
+ break;
+ case NHKF_RUN2:
+ if (!Cmd.num_pad)
+ break;
+ /*FALLTHRU*/
+ case NHKF_RUN:
+ case NHKF_RUN_NOPICKUP:
+#if 0 /*JP*/
+ dothat = "run";
+#else
+ dothat = "\91\96\82é";
+#endif
+ break;
+ case NHKF_FIGHT2:
+ if (!Cmd.num_pad)
+ break;
+ /*FALLTHRU*/
+ case NHKF_FIGHT:
+#if 0 /*JP*/
+ dothat = "fight";
+#else
+ dothat = "\90í\82¤";
+#endif
+ how = ""; /* avoid "fight at yourself" */
+ break;
+ default:
+ prefixhandling = FALSE;
+ break;
+ }
+
+ buf[0] = '\0';
+ /* for movement prefix followed by '.' or (numpad && 's') to mean 'self';
+ note: '-' for hands (inventory form of 'self') is not handled here */
+ if (prefixhandling
+ && (sym == Cmd.spkeys[NHKF_GETDIR_SELF]
+ || (Cmd.num_pad && sym == Cmd.spkeys[NHKF_GETDIR_SELF2]))) {
/*JP
- You_cant("orient yourself that direction.");
+ Sprintf(buf, "You can't %s%s yourself.", dothat, how);
*/
- You_cant("\8cü\82«\82É\8e©\95ª\8e©\90g\82ð\8ew\92è\82Å\82«\82È\82¢\81D");
- return 0;
+ Sprintf(buf, "\8e©\95ª\8e©\90g\82É%s%s\82±\82Æ\82Í\82Å\82«\82È\82¢\81D", dothat, how);
+ /* for movement prefix followed by up or down */
+ } else if (prefixhandling && (sym == '<' || sym == '>')) {
+#if 0 /*JP*/
+ Sprintf(buf, "You can't %s %s.", dothat,
+ /* was "upwards" and "downwards", but they're considered
+ to be variants of canonical "upward" and "downward" */
+ (sym == '<') ? "upward" : "downward");
+#else
+ Sprintf(buf, "%s%s\82±\82Æ\82Í\82Å\82«\82È\82¢\81D",
+ (sym == '<') ? "\8fã\95û\8cü\82É" : "\89º\95û\8cü\82É", dothat);
+#endif
}
- if (!u.dz && (Stunned || (Confusion && !rn2(5))))
- confdir();
- return 1;
-}
-STATIC_OVL boolean
-help_dir(sym, msg)
-char sym;
-const char *msg;
-{
- char ctrl;
- winid win;
- static const char wiz_only_list[] = "EFGIOVW";
- char buf[BUFSZ], buf2[BUFSZ], *explain;
+ /* if '!cmdassist', display via pline() and we're done (note: asking
+ for help at getdir() prompt forces cmdassist for this operation) */
+ if (!viawindow) {
+ if (prefixhandling) {
+ if (!*buf)
+#if 0 /*JP*/
+ Sprintf(buf, "Invalid direction for '%s' prefix.",
+ visctrl(Cmd.spkeys[spkey]));
+#else
+ Sprintf(buf, "'%s'\90Ú\93ª\8e«\82É\82Í\95s\90³\82È\95û\8cü\81D",
+ visctrl(Cmd.spkeys[spkey]));
+#endif
+ pline("%s", buf);
+ return TRUE;
+ }
+ /* when 'cmdassist' is off and caller doesn't insist, do nothing */
+ return FALSE;
+ }
win = create_nhwindow(NHW_TEXT);
if (!win)
return FALSE;
- if (msg) {
+
+ if (*buf) {
+ /* show bad-prefix message instead of general invalid-direction one */
+ putstr(win, 0, buf);
+ putstr(win, 0, "");
+ } else if (msg) {
Sprintf(buf, "cmdassist: %s", msg);
putstr(win, 0, buf);
putstr(win, 0, "");
}
- if (letter(sym)) {
- sym = highc(sym);
- ctrl = (sym - 'A') + 1;
- if ((explain = dowhatdoes_core(ctrl, buf2))
+
+ if (!prefixhandling && (letter(sym) || sym == '[')) {
+ /* '[': old 'cmdhelp' showed ESC as ^[ */
+ sym = highc(sym); /* @A-Z[ (note: letter() accepts '@') */
+ ctrl = (sym - 'A') + 1; /* 0-27 (note: 28-31 aren't applicable) */
+ if ((explain = dowhatdoes_core(ctrl, buf2)) != 0
&& (!index(wiz_only_list, sym) || wizard)) {
Sprintf(buf, "Are you trying to use ^%c%s?", sym,
- index(wiz_only_list, sym)
- ? ""
+ index(wiz_only_list, sym) ? ""
: " as specified in the Guidebook");
putstr(win, 0, buf);
putstr(win, 0, "");
putstr(win, 0, explain);
putstr(win, 0, "");
- putstr(win, 0, "To use that command, you press");
- Sprintf(buf, "the <Ctrl> key, and the <%c> key at the same time.",
- sym);
+ putstr(win, 0,
+ "To use that command, hold down the <Ctrl> key as a shift");
+ Sprintf(buf, "and press the <%c> key.", sym);
putstr(win, 0, buf);
putstr(win, 0, "");
}
}
- if (NODIAG(u.umonnum)) {
- putstr(win, 0, "Valid direction keys in your current form are:");
- Sprintf(buf, " %c ", Cmd.move_N);
- putstr(win, 0, buf);
- putstr(win, 0, " | ");
- Sprintf(buf, " %c- . -%c", Cmd.move_W, Cmd.move_E);
- putstr(win, 0, buf);
- putstr(win, 0, " | ");
- Sprintf(buf, " %c ", Cmd.move_S);
- putstr(win, 0, buf);
- } else {
- putstr(win, 0, "Valid direction keys are:");
- Sprintf(buf, " %c %c %c", Cmd.move_NW, Cmd.move_N,
- Cmd.move_NE);
- putstr(win, 0, buf);
- putstr(win, 0, " \\ | / ");
- Sprintf(buf, " %c- . -%c", Cmd.move_W, Cmd.move_E);
- putstr(win, 0, buf);
- putstr(win, 0, " / | \\ ");
- Sprintf(buf, " %c %c %c", Cmd.move_SW, Cmd.move_S,
- Cmd.move_SE);
- putstr(win, 0, buf);
- };
- putstr(win, 0, "");
- putstr(win, 0, " < up");
- putstr(win, 0, " > down");
- putstr(win, 0, " . direct at yourself");
+
+#if 0 /*JP:T*/
+ Sprintf(buf, "Valid direction keys%s%s%s are:",
+ prefixhandling ? " to " : "", prefixhandling ? dothat : "",
+ NODIAG(u.umonnum) ? " in your current form" : "");
+#else
+ Sprintf(buf, "%s%s%s\97L\8cø\82È\95û\8cü\8ew\92è\82Í:",
+ prefixhandling ? dothat : "", prefixhandling ? "\82½\82ß\82Ì" : "",
+ NODIAG(u.umonnum) ? " \8c»\8dÝ\82Ì\8ep\82Å\82Ì" : "");
+#endif
+ putstr(win, 0, buf);
+ show_direction_keys(win, !prefixhandling ? '.' : ' ', NODIAG(u.umonnum));
+
+ if (!prefixhandling || spkey == NHKF_NOPICKUP) {
+ /* NOPICKUP: unlike the other prefix keys, 'm' allows up/down for
+ stair traversal; we won't get here when "m<" or "m>" has been
+ given but we include up and down for 'm'+invalid_direction;
+ self is excluded as a viable direction for every prefix */
+ putstr(win, 0, "");
+/*JP
+ putstr(win, 0, " < up");
+*/
+ putstr(win, 0, " < \8fã");
+/*JP
+ putstr(win, 0, " > down");
+*/
+ putstr(win, 0, " > \89º");
+ if (!prefixhandling) {
+ int selfi = Cmd.num_pad ? NHKF_GETDIR_SELF2 : NHKF_GETDIR_SELF;
+
+#if 0 /*JP:T*/
+ Sprintf(buf, " %4s direct at yourself",
+ visctrl(Cmd.spkeys[selfi]));
+#else
+ Sprintf(buf, " %4s \8e©\95ª\82É\8cü\82¯\82é",
+ visctrl(Cmd.spkeys[selfi]));
+#endif
+ putstr(win, 0, buf);
+ }
+ }
+
if (msg) {
/* non-null msg means that this wasn't an explicit user request */
putstr(win, 0, "");
return x >= 1 && x <= COLNO - 1 && y >= 0 && y <= ROWNO - 1;
}
+/* #herecmdmenu command */
+STATIC_PTR int
+doherecmdmenu(VOID_ARGS)
+{
+ char ch = here_cmd_menu(TRUE);
+
+ return ch ? 1 : 0;
+}
+
+/* #therecmdmenu command, a way to test there_cmd_menu without mouse */
+STATIC_PTR int
+dotherecmdmenu(VOID_ARGS)
+{
+ char ch;
+
+ if (!getdir((const char *) 0) || !isok(u.ux + u.dx, u.uy + u.dy))
+ return 0;
+
+ if (u.dx || u.dy)
+ ch = there_cmd_menu(TRUE, u.ux + u.dx, u.uy + u.dy);
+ else
+ ch = here_cmd_menu(TRUE);
+
+ return ch ? 1 : 0;
+}
+
+STATIC_OVL void
+add_herecmd_menuitem(win, func, text)
+winid win;
+int NDECL((*func));
+const char *text;
+{
+ char ch;
+ anything any;
+
+ if ((ch = cmd_from_func(func)) != '\0') {
+ any = zeroany;
+ any.a_nfunc = func;
+ add_menu(win, NO_GLYPH, &any, 0, 0, ATR_NONE, text, MENU_UNSELECTED);
+ }
+}
+
+STATIC_OVL char
+there_cmd_menu(doit, x, y)
+boolean doit;
+int x, y;
+{
+ winid win;
+ char ch;
+ char buf[BUFSZ];
+ schar typ = levl[x][y].typ;
+ int npick, K = 0;
+ menu_item *picks = (menu_item *) 0;
+ struct trap *ttmp;
+ struct monst *mtmp;
+
+ win = create_nhwindow(NHW_MENU);
+ start_menu(win);
+
+ if (IS_DOOR(typ)) {
+ boolean key_or_pick, card;
+ int dm = levl[x][y].doormask;
+
+ if ((dm & (D_CLOSED | D_LOCKED))) {
+ add_herecmd_menuitem(win, doopen, "Open the door"), ++K;
+ /* unfortunately there's no lknown flag for doors to
+ remember the locked/unlocked state */
+ key_or_pick = (carrying(SKELETON_KEY) || carrying(LOCK_PICK));
+ card = (carrying(CREDIT_CARD) != 0);
+ if (key_or_pick || card) {
+ Sprintf(buf, "%sunlock the door",
+ key_or_pick ? "lock or " : "");
+ add_herecmd_menuitem(win, doapply, upstart(buf)), ++K;
+ }
+ /* unfortunately there's no tknown flag for doors (or chests)
+ to remember whether a trap had been found */
+ add_herecmd_menuitem(win, dountrap,
+ "Search the door for a trap"), ++K;
+ /* [what about #force?] */
+ add_herecmd_menuitem(win, dokick, "Kick the door"), ++K;
+ } else if ((dm & D_ISOPEN)) {
+ add_herecmd_menuitem(win, doclose, "Close the door"), ++K;
+ }
+ }
+
+ if (typ <= SCORR)
+ add_herecmd_menuitem(win, dosearch, "Search for secret doors"), ++K;
+
+ if ((ttmp = t_at(x, y)) != 0 && ttmp->tseen) {
+ add_herecmd_menuitem(win, doidtrap, "Examine trap"), ++K;
+ if (ttmp->ttyp != VIBRATING_SQUARE)
+ add_herecmd_menuitem(win, dountrap, "Attempt to disarm trap"), ++K;
+ }
+
+ mtmp = m_at(x, y);
+ if (mtmp && !canspotmon(mtmp))
+ mtmp = 0;
+ if (mtmp && which_armor(mtmp, W_SADDLE)) {
+ char *mnam = x_monnam(mtmp, ARTICLE_THE, (char *) 0,
+ SUPPRESS_SADDLE, FALSE);
+
+ if (!u.usteed) {
+ Sprintf(buf, "Ride %s", mnam);
+ add_herecmd_menuitem(win, doride, buf), ++K;
+ }
+ Sprintf(buf, "Remove saddle from %s", mnam);
+ add_herecmd_menuitem(win, doloot, buf), ++K;
+ }
+ if (mtmp && can_saddle(mtmp) && !which_armor(mtmp, W_SADDLE)
+ && carrying(SADDLE)) {
+ Sprintf(buf, "Put saddle on %s", mon_nam(mtmp)), ++K;
+ add_herecmd_menuitem(win, doapply, buf);
+ }
+#if 0
+ if (mtmp || glyph_is_invisible(glyph_at(x, y))) {
+ /* "Attack %s", mtmp ? mon_nam(mtmp) : "unseen creature" */
+ } else {
+ /* "Move %s", direction */
+ }
+#endif
+
+ if (K) {
+ end_menu(win, "What do you want to do?");
+ npick = select_menu(win, PICK_ONE, &picks);
+ } else {
+ pline("No applicable actions.");
+ npick = 0;
+ }
+ destroy_nhwindow(win);
+ ch = '\0';
+ if (npick > 0) {
+ int NDECL((*func)) = picks->item.a_nfunc;
+ free((genericptr_t) picks);
+
+ if (doit) {
+ int ret = (*func)();
+
+ ch = (char) ret;
+ } else {
+ ch = cmd_from_func(func);
+ }
+ }
+ return ch;
+}
+
+STATIC_OVL char
+here_cmd_menu(doit)
+boolean doit;
+{
+ winid win;
+ char ch;
+ char buf[BUFSZ];
+ schar typ = levl[u.ux][u.uy].typ;
+ int npick;
+ menu_item *picks = (menu_item *) 0;
+
+ win = create_nhwindow(NHW_MENU);
+ start_menu(win);
+
+ if (IS_FOUNTAIN(typ) || IS_SINK(typ)) {
+ Sprintf(buf, "Drink from the %s",
+ defsyms[IS_FOUNTAIN(typ) ? S_fountain : S_sink].explanation);
+ add_herecmd_menuitem(win, dodrink, buf);
+ }
+ if (IS_FOUNTAIN(typ))
+ add_herecmd_menuitem(win, dodip,
+ "Dip something into the fountain");
+ if (IS_THRONE(typ))
+ add_herecmd_menuitem(win, dosit,
+ "Sit on the throne");
+
+ if ((u.ux == xupstair && u.uy == yupstair)
+ || (u.ux == sstairs.sx && u.uy == sstairs.sy && sstairs.up)
+ || (u.ux == xupladder && u.uy == yupladder)) {
+ Sprintf(buf, "Go up the %s",
+ (u.ux == xupladder && u.uy == yupladder)
+ ? "ladder" : "stairs");
+ add_herecmd_menuitem(win, doup, buf);
+ }
+ if ((u.ux == xdnstair && u.uy == ydnstair)
+ || (u.ux == sstairs.sx && u.uy == sstairs.sy && !sstairs.up)
+ || (u.ux == xdnladder && u.uy == ydnladder)) {
+ Sprintf(buf, "Go down the %s",
+ (u.ux == xupladder && u.uy == yupladder)
+ ? "ladder" : "stairs");
+ add_herecmd_menuitem(win, dodown, buf);
+ }
+ if (u.usteed) { /* another movement choice */
+ Sprintf(buf, "Dismount %s",
+ x_monnam(u.usteed, ARTICLE_THE, (char *) 0,
+ SUPPRESS_SADDLE, FALSE));
+ add_herecmd_menuitem(win, doride, buf);
+ }
+
+#if 0
+ if (Upolyd) { /* before objects */
+ Sprintf(buf, "Use %s special ability",
+ s_suffix(mons[u.umonnum].mname));
+ add_herecmd_menuitem(win, domonability, buf);
+ }
+#endif
+
+ if (OBJ_AT(u.ux, u.uy)) {
+ struct obj *otmp = level.objects[u.ux][u.uy];
+
+ Sprintf(buf, "Pick up %s", otmp->nexthere ? "items" : doname(otmp));
+ add_herecmd_menuitem(win, dopickup, buf);
+
+ if (Is_container(otmp)) {
+ Sprintf(buf, "Loot %s", doname(otmp));
+ add_herecmd_menuitem(win, doloot, buf);
+ }
+ if (otmp->oclass == FOOD_CLASS) {
+ Sprintf(buf, "Eat %s", doname(otmp));
+ add_herecmd_menuitem(win, doeat, buf);
+ }
+ }
+
+ if (invent)
+ add_herecmd_menuitem(win, dodrop, "Drop items");
+
+ add_herecmd_menuitem(win, donull, "Rest one turn");
+ add_herecmd_menuitem(win, dosearch, "Search around you");
+ add_herecmd_menuitem(win, dolook, "Look at what is here");
+
+ end_menu(win, "What do you want to do?");
+ npick = select_menu(win, PICK_ONE, &picks);
+ destroy_nhwindow(win);
+ ch = '\0';
+ if (npick > 0) {
+ int NDECL((*func)) = picks->item.a_nfunc;
+ free((genericptr_t) picks);
+
+ if (doit) {
+ int ret = (*func)();
+
+ ch = (char) ret;
+ } else {
+ ch = cmd_from_func(func);
+ }
+ }
+ return ch;
+}
+
+
static NEARDATA int last_multi;
/*
if (iflags.clicklook && mod == CLICK_2) {
clicklook_cc.x = x;
clicklook_cc.y = y;
- cmd[0] = CMD_CLICKLOOK;
+ cmd[0] = Cmd.spkeys[NHKF_CLICKLOOK];
return cmd;
}
} else {
u.tx = u.ux + x;
u.ty = u.uy + y;
- cmd[0] = CMD_TRAVEL;
+ cmd[0] = Cmd.spkeys[NHKF_TRAVEL];
return cmd;
}
if (x == 0 && y == 0) {
+ if (iflags.herecmd_menu) {
+ cmd[0] = here_cmd_menu(FALSE);
+ return cmd;
+ }
+
/* here */
if (IS_FOUNTAIN(levl[u.ux][u.uy].typ)
|| IS_SINK(levl[u.ux][u.uy].typ)) {
- cmd[0] = mod == CLICK_1 ? 'q' : M('d');
+ cmd[0] = cmd_from_func(mod == CLICK_1 ? dodrink : dodip);
return cmd;
} else if (IS_THRONE(levl[u.ux][u.uy].typ)) {
- cmd[0] = M('s');
+ cmd[0] = cmd_from_func(dosit);
return cmd;
} else if ((u.ux == xupstair && u.uy == yupstair)
|| (u.ux == sstairs.sx && u.uy == sstairs.sy
&& sstairs.up)
|| (u.ux == xupladder && u.uy == yupladder)) {
- return "<";
+ cmd[0] = cmd_from_func(doup);
+ return cmd;
} else if ((u.ux == xdnstair && u.uy == ydnstair)
|| (u.ux == sstairs.sx && u.uy == sstairs.sy
&& !sstairs.up)
|| (u.ux == xdnladder && u.uy == ydnladder)) {
- return ">";
+ cmd[0] = cmd_from_func(dodown);
+ return cmd;
} else if (OBJ_AT(u.ux, u.uy)) {
- cmd[0] =
- Is_container(level.objects[u.ux][u.uy]) ? M('l') : ',';
+ cmd[0] = cmd_from_func(Is_container(level.objects[u.ux][u.uy])
+ ? doloot : dopickup);
return cmd;
} else {
- return "."; /* just rest */
+ cmd[0] = cmd_from_func(donull); /* just rest */
+ return cmd;
}
}
&& !test_move(u.ux, u.uy, x, y, TEST_MOVE)) {
cmd[1] = Cmd.dirchars[dir];
cmd[2] = '\0';
+ if (iflags.herecmd_menu) {
+ cmd[0] = there_cmd_menu(FALSE, u.ux + x, u.uy + y);
+ if (cmd[0] == '\0')
+ cmd[1] = '\0';
+ return cmd;
+ }
+
if (IS_DOOR(levl[u.ux + x][u.uy + y].typ)) {
/* slight assistance to the player: choose kick/open for them
*/
if (levl[u.ux + x][u.uy + y].doormask & D_LOCKED) {
- cmd[0] = C('d');
+ cmd[0] = cmd_from_func(dokick);
return cmd;
}
if (levl[u.ux + x][u.uy + y].doormask & D_CLOSED) {
- cmd[0] = 'o';
+ cmd[0] = cmd_from_func(doopen);
return cmd;
}
}
if (levl[u.ux + x][u.uy + y].typ <= SCORR) {
- cmd[0] = 's';
+ cmd[0] = cmd_from_func(dosearch);
cmd[1] = 0;
return cmd;
}
else
x = sgn(x), y = sgn(y);
- if (x == 0 && y == 0) /* map click on player to "rest" command */
- return ".";
-
+ if (x == 0 && y == 0) {
+ /* map click on player to "rest" command */
+ cmd[0] = cmd_from_func(donull);
+ return cmd;
+ }
dir = xytod(x, y);
}
return cmd;
}
+char
+get_count(allowchars, inkey, maxcount, count, historical)
+char *allowchars;
+char inkey;
+long maxcount;
+long *count;
+boolean historical; /* whether to include in message history: True => yes */
+{
+ char qbuf[QBUFSZ];
+ int key;
+ long cnt = 0L;
+ boolean backspaced = FALSE;
+ /* this should be done in port code so that we have erase_char
+ and kill_char available; we can at least fake erase_char */
+#define STANDBY_erase_char '\177'
+
+ for (;;) {
+ if (inkey) {
+ key = inkey;
+ inkey = '\0';
+ } else
+ key = readchar();
+
+ if (digit(key)) {
+ cnt = 10L * cnt + (long) (key - '0');
+ if (cnt < 0)
+ cnt = 0;
+ else if (maxcount > 0 && cnt > maxcount)
+ cnt = maxcount;
+ } else if (cnt && (key == '\b' || key == STANDBY_erase_char)) {
+ cnt = cnt / 10;
+ backspaced = TRUE;
+ } else if (key == Cmd.spkeys[NHKF_ESC]) {
+ break;
+ } else if (!allowchars || index(allowchars, key)) {
+ *count = cnt;
+ break;
+ }
+
+ if (cnt > 9 || backspaced) {
+ clear_nhwindow(WIN_MESSAGE);
+ if (backspaced && !cnt) {
+/*JP
+ Sprintf(qbuf, "Count: ");
+*/
+ Sprintf(qbuf, "\90\94: ");
+ } else {
+/*JP
+ Sprintf(qbuf, "Count: %ld", cnt);
+*/
+ Sprintf(qbuf, "\90\94: %ld", cnt);
+ backspaced = FALSE;
+ }
+ custompline(SUPPRESS_HISTORY, "%s", qbuf);
+ mark_synch();
+ }
+ }
+
+ if (historical) {
+/*JP
+ Sprintf(qbuf, "Count: %ld ", *count);
+*/
+ Sprintf(qbuf, "\90\94: %ld ", *count);
+ (void) key2txt((uchar) key, eos(qbuf));
+ putmsghistory(qbuf, FALSE);
+ }
+
+ return key;
+}
+
+
STATIC_OVL char *
parse()
{
static char in_line[COLNO];
#endif
register int foo;
- boolean prezero = FALSE;
+ iflags.in_parse = TRUE;
multi = 0;
context.move = 1;
flush_screen(1); /* Flush screen buffer. Put the cursor on the hero. */
#ifdef ALTMETA
alt_esc = iflags.altmeta; /* readchar() hack */
#endif
- if (!Cmd.num_pad || (foo = readchar()) == 'n')
- for (;;) {
- foo = readchar();
- if (foo >= '0' && foo <= '9') {
- multi = 10 * multi + foo - '0';
- if (multi < 0 || multi >= LARGEST_INT)
- multi = LARGEST_INT;
- if (multi > 9) {
- clear_nhwindow(WIN_MESSAGE);
-/*JP
- Sprintf(in_line, "Count: %d", multi);
-*/
- Sprintf(in_line, "\90\94: %d", multi);
- pline1(in_line);
- mark_synch();
- }
- last_multi = multi;
- if (!multi && foo == '0')
- prezero = TRUE;
- } else
- break; /* not a digit */
- }
+ if (!Cmd.num_pad || (foo = readchar()) == Cmd.spkeys[NHKF_COUNT]) {
+ long tmpmulti = multi;
+
+ foo = get_count((char *) 0, '\0', LARGEST_INT, &tmpmulti, FALSE);
+ last_multi = multi = tmpmulti;
+ }
#ifdef ALTMETA
alt_esc = FALSE; /* readchar() reset */
#endif
- if (foo == '\033') { /* esc cancels count (TH) */
+ if (iflags.debug_fuzzer /* if fuzzing, override '!' and ^Z */
+ && (Cmd.commands[foo & 0x0ff]
+ && (Cmd.commands[foo & 0x0ff]->ef_funct == dosuspend_core
+ || Cmd.commands[foo & 0x0ff]->ef_funct == dosh_core)))
+ foo = Cmd.spkeys[NHKF_ESC];
+
+ if (foo == Cmd.spkeys[NHKF_ESC]) { /* esc cancels count (TH) */
clear_nhwindow(WIN_MESSAGE);
multi = last_multi = 0;
- } else if (foo == DOAGAIN || in_doagain) {
+ } else if (foo == Cmd.spkeys[NHKF_DOAGAIN] || in_doagain) {
multi = last_multi;
} else {
last_multi = multi;
from the number pad. Now do not map them until here. */
switch (foo) {
case '5':
- foo = 'g';
+ foo = Cmd.spkeys[NHKF_RUSH];
break;
case M('5'):
- foo = 'G';
+ foo = Cmd.spkeys[NHKF_RUN];
break;
case M('0'):
- foo = 'I';
+ foo = Cmd.spkeys[NHKF_DOINV];
break;
default:
break; /* as is */
in_line[0] = foo;
in_line[1] = '\0';
- if (foo == 'g' || foo == 'G' || foo == 'm' || foo == 'M' || foo == 'F'
- || (Cmd.num_pad && (foo == '5' || foo == '-'))) {
+ if (prefix_cmd(foo)) {
foo = readchar();
savech((char) foo);
in_line[1] = foo;
in_line[2] = 0;
}
clear_nhwindow(WIN_MESSAGE);
- if (prezero)
- in_line[0] = '\033';
+
+ iflags.in_parse = FALSE;
return in_line;
}
#ifdef NOSAVEONHANGUP
#ifdef INSURANCE
if (flags.ins_chkpt && program_state.something_worth_saving)
- program_statue.preserve_locks = 1; /* keep files for recovery */
+ program_state.preserve_locks = 1; /* keep files for recovery */
#endif
program_state.something_worth_saving = 0; /* don't save */
#endif
if (iflags.window_inited)
exit_nhwindows((char *) 0);
clearlocks();
- terminate(EXIT_SUCCESS);
+ nh_terminate(EXIT_SUCCESS);
/*NOTREACHED*/ /* not necessarily true for vms... */
return;
}
register int sym;
int x = u.ux, y = u.uy, mod = 0;
+ if (iflags.debug_fuzzer)
+ return randomkey();
if (*readchar_queue)
sym = *readchar_queue++;
else
sym = '\033';
else if (sym != '\033')
sym |= 0200; /* force 8th bit on */
-#endif /*ALTMETA*/
+#endif /*ALTMETA*/
} else if (sym == 0) {
/* click event */
readchar_queue = click_to_cmd(x, y, mod);
return (char) sym;
}
+/* '_' command, #travel, via keyboard rather than mouse click */
STATIC_PTR int
dotravel(VOID_ARGS)
{
- /* Keyboard travel command */
static char cmd[2];
coord cc;
+ /* [FIXME? Supporting the ability to disable traveling via mouse
+ click makes some sense, depending upon overall mouse usage.
+ Disabling '_' on a user by user basis makes no sense at all since
+ even if it is typed by accident, aborting when picking a target
+ destination is trivial. Travel via mouse predates travel via '_',
+ and this use of OPTION=!travel is probably just a mistake....] */
if (!flags.travelcmd)
return 0;
+
cmd[1] = 0;
cc.x = iflags.travelcc.x;
cc.y = iflags.travelcc.y;
- if (cc.x == -1 && cc.y == -1) {
+ if (cc.x == 0 && cc.y == 0) {
/* No cached destination, start attempt from current position */
cc.x = u.ux;
cc.y = u.uy;
}
+ iflags.getloc_travelmode = TRUE;
+ if (iflags.menu_requested) {
+ int gf = iflags.getloc_filter;
+ iflags.getloc_filter = GFILTER_VIEW;
+ if (!getpos_menu(&cc, GLOC_INTERESTING)) {
+ iflags.getloc_filter = gf;
+ iflags.getloc_travelmode = FALSE;
+ return 0;
+ }
+ iflags.getloc_filter = gf;
+ } else {
/*JP
- pline("Where do you want to travel to?");
+ pline("Where do you want to travel to?");
*/
- pline("\82Ç\82±\82É\88Ú\93®\82·\82é\81H");
+ pline("\82Ç\82±\82É\88Ú\93®\82·\82é\81H");
/*JP
- if (getpos(&cc, TRUE, "the desired destination") < 0) {
+ if (getpos(&cc, TRUE, "the desired destination") < 0) {
*/
- if (getpos(&cc, TRUE, "\88Ú\93®\90æ") < 0) {
- /* user pressed ESC */
- return 0;
+ if (getpos(&cc, TRUE, "\88Ú\93®\90æ") < 0) {
+ /* user pressed ESC */
+ iflags.getloc_travelmode = FALSE;
+ return 0;
+ }
}
+ iflags.getloc_travelmode = FALSE;
iflags.travelcc.x = u.tx = cc.x;
iflags.travelcc.y = u.ty = cc.y;
- cmd[0] = CMD_TRAVEL;
+ cmd[0] = Cmd.spkeys[NHKF_TRAVEL];
readchar_queue = cmd;
return 0;
}
-#ifdef PORT_DEBUG
-extern void NDECL(win32con_debug_keystrokes);
-extern void NDECL(win32con_handler_info);
-
-int
-wiz_port_debug()
-{
- int n, k;
- winid win;
- anything any;
- int item = 'a';
- int num_menu_selections;
- struct menu_selection_struct {
- char *menutext;
- void NDECL((*fn));
- } menu_selections[] = {
-#ifdef WIN32
- { "test win32 keystrokes (tty only)", win32con_debug_keystrokes },
- { "show keystroke handler information (tty only)",
- win32con_handler_info },
-#endif
- { (char *) 0, (void NDECL((*) )) 0 } /* array terminator */
- };
-
- num_menu_selections = SIZE(menu_selections) - 1;
- if (num_menu_selections > 0) {
- menu_item *pick_list;
- win = create_nhwindow(NHW_MENU);
- start_menu(win);
- for (k = 0; k < num_menu_selections; ++k) {
- any.a_int = k + 1;
- add_menu(win, NO_GLYPH, &any, item++, 0, ATR_NONE,
- menu_selections[k].menutext, MENU_UNSELECTED);
- }
- end_menu(win, "Which port debugging feature?");
- n = select_menu(win, PICK_ONE, &pick_list);
- destroy_nhwindow(win);
- if (n > 0) {
- n = pick_list[0].item.a_int - 1;
- free((genericptr_t) pick_list);
- /* execute the function */
- (*menu_selections[n].fn)();
- }
- } else
- pline("No port-specific debug capability defined.");
- return 0;
-}
-#endif /*PORT_DEBUG*/
-
/*
* Parameter validator for generic yes/no function to prevent
* the core from sending too long a prompt string to the
const char *query, *resp;
char def;
{
- char qbuf[QBUFSZ];
+ char res, qbuf[QBUFSZ];
+#ifdef DUMPLOG
+ extern unsigned saved_pline_index; /* pline.c */
+ unsigned idx = saved_pline_index;
+ /* buffer to hold query+space+formatted_single_char_response */
+ char dumplog_buf[QBUFSZ + 1 + 15]; /* [QBUFSZ+1+7] should suffice */
+#endif
iflags.last_msg = PLNMSG_UNKNOWN; /* most recent pline is clobbered */
/* maximum acceptable length is QBUFSZ-1 */
- if (strlen(query) < QBUFSZ)
- return (*windowprocs.win_yn_function)(query, resp, def);
-
- /* caller shouldn't have passed anything this long */
- paniclog("Query truncated: ", query);
- (void) strncpy(qbuf, query, QBUFSZ - 1 - 3);
- Strcpy(&qbuf[QBUFSZ - 1 - 3], "...");
- return (*windowprocs.win_yn_function)(qbuf, resp, def);
+ if (strlen(query) >= QBUFSZ) {
+ /* caller shouldn't have passed anything this long */
+ paniclog("Query truncated: ", query);
+ (void) strncpy(qbuf, query, QBUFSZ - 1 - 3);
+ Strcpy(&qbuf[QBUFSZ - 1 - 3], "...");
+ query = qbuf;
+ }
+ res = (*windowprocs.win_yn_function)(query, resp, def);
+#ifdef DUMPLOG
+ if (idx == saved_pline_index) {
+ /* when idx is still the same as saved_pline_index, the interface
+ didn't put the prompt into saved_plines[]; we put a simplified
+ version in there now (without response choices or default) */
+ Sprintf(dumplog_buf, "%s ", query);
+ (void) key2txt((uchar) res, eos(dumplog_buf));
+ dumplogmsg(dumplog_buf);
+ }
+#endif
+ return res;
}
/* for paranoid_confirm:quit,die,attack prompting */
to give the go-ahead for this query; default is "no" unless the
ParanoidConfirm flag is set in which case there's no default */
if (be_paranoid) {
- char qbuf[QBUFSZ], ans[BUFSZ];
- const char *promptprefix = "", *responsetype = ParanoidConfirm
- ? "(yes|no)"
- : "(yes) [no]";
- int trylimit = 6; /* 1 normal, 5 more with "Yes or No:" prefix */
+ char pbuf[BUFSZ], qbuf[QBUFSZ], ans[BUFSZ];
+ const char *promptprefix = "",
+ *responsetype = ParanoidConfirm ? "(yes|no)" : "(yes) [no]";
+ int k, trylimit = 6; /* 1 normal, 5 more with "Yes or No:" prefix */
+ copynchars(pbuf, prompt, BUFSZ - 1);
/* in addition to being paranoid about this particular
query, we might be even more paranoid about all paranoia
responses (ie, ParanoidConfirm is set) in which case we
require "no" to reject in addition to "yes" to confirm
(except we won't loop if response is ESC; it means no) */
do {
- Sprintf(qbuf, "%s%s %s", promptprefix, prompt, responsetype);
+ /* make sure we won't overflow a QBUFSZ sized buffer */
+ k = (int) (strlen(promptprefix) + 1 + strlen(responsetype));
+ if ((int) strlen(pbuf) + k > QBUFSZ - 1) {
+ /* chop off some at the end */
+ Strcpy(pbuf + (QBUFSZ - 1) - k - 4, "...?"); /* -4: "...?" */
+ }
+
+ Sprintf(qbuf, "%s%s %s", promptprefix, pbuf, responsetype);
+ *ans = '\0';
getlin(qbuf, ans);
(void) mungspaces(ans);
confirmed_ok = !strcmpi(ans, "yes");
return confirmed_ok;
}
-int
-dosuspend_core()
+/* ^Z command, #suspend */
+STATIC_PTR int
+dosuspend_core(VOID_ARGS)
{
#ifdef SUSPEND
/* Does current window system support suspend? */
dosuspend();
} else
#endif
- Norep("Suspend command not available.");
+ Norep(cmdnotavail, "#suspend");
+ return 0;
+}
+
+/* '!' command, #shell */
+STATIC_PTR int
+dosh_core(VOID_ARGS)
+{
+#ifdef SHELL
+ /* access restrictions, if any, are handled in port code */
+ dosh();
+#else
+ Norep(cmdnotavail, "#shell");
+#endif
return 0;
}
OSDN Git Service
