-/* NetHack 3.6 options.c $NHDT-Date: 1448241657 2015/11/23 01:20:57 $ $NHDT-Branch: master $:$NHDT-Revision: 1.243 $ */
+/* NetHack 3.6 options.c $NHDT-Date: 1510963525 2017/11/18 00:05:25 $ $NHDT-Branch: NetHack-3.6.0 $:$NHDT-Revision: 1.319 $ */
/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
+/*-Copyright (c) Michael Allison, 2008. */
/* 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 */
+/* JNetHack may be freely redistributed. See license for details. */
+
#ifdef OPTION_LISTS_ONLY /* (AMIGA) external program for opt lists */
#include "config.h"
#include "objclass.h"
#define PREFER_TILED FALSE
#endif
-#define MESSAGE_OPTION 1
-#define STATUS_OPTION 2
-#define MAP_OPTION 3
-#define MENU_OPTION 4
-#define TEXT_OPTION 5
+enum window_option_types {
+ MESSAGE_OPTION = 1,
+ STATUS_OPTION,
+ MAP_OPTION,
+ MENU_OPTION,
+ TEXT_OPTION
+};
#define PILE_LIMIT_DFLT 5
#else
{ "asksavedisk", (boolean *) 0, FALSE, SET_IN_FILE },
#endif
+ { "autodescribe", &iflags.autodescribe, FALSE, SET_IN_GAME },
{ "autodig", &flags.autodig, FALSE, SET_IN_GAME },
{ "autoopen", &flags.autoopen, TRUE, SET_IN_GAME },
{ "autopickup", &flags.pickup, TRUE, SET_IN_GAME },
#endif
{ "confirm", &flags.confirm, TRUE, SET_IN_GAME },
{ "dark_room", &flags.dark_room, TRUE, SET_IN_GAME },
- { "eight_bit_tty", &iflags.wc_eight_bit_input, FALSE,
- SET_IN_GAME }, /*WC*/
+ { "eight_bit_tty", &iflags.wc_eight_bit_input, FALSE, SET_IN_GAME }, /*WC*/
#ifdef TTY_GRAPHICS
{ "extmenu", &iflags.extmenu, FALSE, SET_IN_GAME },
#else
#else
{ "flush", (boolean *) 0, FALSE, SET_IN_FILE },
#endif
+ { "force_invmenu", &iflags.force_invmenu, FALSE, SET_IN_GAME },
{ "fullscreen", &iflags.wc2_fullscreen, FALSE, SET_IN_FILE },
+ { "goldX", &iflags.goldX, FALSE, SET_IN_GAME },
{ "help", &flags.help, TRUE, SET_IN_GAME },
+ { "herecmd_menu", &iflags.herecmd_menu, FALSE, SET_IN_GAME },
{ "hilite_pet", &iflags.wc_hilite_pet, FALSE, SET_IN_GAME }, /*WC*/
{ "hilite_pile", &iflags.hilite_pile, FALSE, SET_IN_GAME },
+ { "hitpointbar", &iflags.wc2_hitpointbar, FALSE, SET_IN_GAME }, /*WC2*/
#ifndef MAC
{ "ignintr", &flags.ignintr, FALSE, SET_IN_GAME },
#else
{ "mention_walls", &iflags.mention_walls, FALSE, SET_IN_GAME },
{ "menucolors", &iflags.use_menu_color, FALSE, SET_IN_GAME },
/* for menu debugging only*/
- { "menu_tab_sep", &iflags.menu_tab_sep, FALSE, SET_IN_GAME },
+ { "menu_tab_sep", &iflags.menu_tab_sep, FALSE, SET_IN_WIZGAME },
{ "menu_objsyms", &iflags.menu_head_objsym, FALSE, SET_IN_GAME },
+#ifdef TTY_GRAPHICS
+ { "menu_overlay", &iflags.menu_overlay, TRUE, SET_IN_GAME },
+#else
+ { "menu_overlay", (boolean *) 0, FALSE, SET_IN_FILE },
+#endif
{ "mouse_support", &iflags.wc_mouse_support, TRUE, DISP_IN_GAME }, /*WC*/
#ifdef NEWS
{ "news", &iflags.news, TRUE, DISP_IN_GAME },
DISP_IN_GAME },
#endif
{ "safe_pet", &flags.safe_dog, TRUE, SET_IN_GAME },
- { "sanity_check", &iflags.sanity_check, FALSE, SET_IN_GAME },
+ { "sanity_check", &iflags.sanity_check, FALSE, SET_IN_WIZGAME },
{ "selectsaved", &iflags.wc2_selectsaved, TRUE, DISP_IN_GAME }, /*WC*/
{ "showexp", &flags.showexp, FALSE, SET_IN_GAME },
{ "showrace", &flags.showrace, FALSE, SET_IN_GAME },
{ "sparkle", &flags.sparkle, TRUE, SET_IN_GAME },
{ "splash_screen", &iflags.wc_splash_screen, TRUE, DISP_IN_GAME }, /*WC*/
{ "standout", &flags.standout, FALSE, SET_IN_GAME },
-#if defined(STATUS_VIA_WINDOWPORT) && defined(STATUS_HILITES)
- { "statushilites", &iflags.use_status_hilites, TRUE, SET_IN_GAME },
-#else
- { "statushilites", &iflags.use_status_hilites, FALSE, DISP_IN_GAME },
-#endif
+ { "status_updates", &iflags.status_updates, TRUE, DISP_IN_GAME },
{ "tiled_map", &iflags.wc_tiled_map, PREFER_TILED, DISP_IN_GAME }, /*WC*/
{ "time", &flags.time, FALSE, SET_IN_GAME },
#ifdef TIMED_DELAY
{ "use_inverse", &iflags.wc_inverse, FALSE, SET_IN_GAME }, /*WC*/
#endif
{ "verbose", &flags.verbose, TRUE, SET_IN_GAME },
+#ifdef TTY_TILES_ESCCODES
+ { "vt_tiledata", &iflags.vt_tiledata, FALSE, SET_IN_FILE },
+#else
+ { "vt_tiledata", (boolean *) 0, FALSE, SET_IN_FILE },
+#endif
+ { "whatis_menu", &iflags.getloc_usemenu, FALSE, SET_IN_GAME },
+ { "whatis_moveskip", &iflags.getloc_moveskip, FALSE, SET_IN_GAME },
+ { "wizweight", &iflags.wizweight, FALSE, SET_IN_WIZGAME },
{ "wraptext", &iflags.wc2_wraptext, FALSE, SET_IN_GAME },
#ifdef ZEROCOMP
{ "zerocomp", &iflags.zerocomp,
* a different format */
int optflags;
} compopt[] = {
+/*JP
{ "align", "your starting alignment (lawful, neutral, or chaotic)", 8,
+*/
+ { "align", "\83Q\81[\83\80\83X\83^\81[\83g\8e\9e\82Ì\91®\90« (lawful, neutral, or chaotic\82Ì\82¢\82¸\82ê\82©)", 8,
DISP_IN_GAME },
+#if 0 /*JP*/
{ "align_message", "message window alignment", 20, DISP_IN_GAME }, /*WC*/
+#else
+ { "align_message", "\83\81\83b\83Z\81[\83W\83E\83B\83\93\83h\83E\82Ì\91µ\82¦", 20, DISP_IN_GAME }, /*WC*/
+#endif
+#if 0 /*JP*/
{ "align_status", "status window alignment", 20, DISP_IN_GAME }, /*WC*/
+#else
+ { "align_status", "\8fó\8bµ\83E\83B\83\93\83h\83E\82Ì\91µ\82¦", 20, DISP_IN_GAME }, /*WC*/
+#endif
+/*JP
{ "altkeyhandler", "alternate key handler", 20, DISP_IN_GAME },
+*/
+ { "altkeyhandler", "ALT\83L\81[\83n\83\93\83h\83\89", 20, DISP_IN_GAME },
#ifdef BACKWARD_COMPAT
+/*JP
{ "boulder", "deprecated (use S_boulder in sym file instead)", 1,
- SET_IN_FILE },
+*/
+ { "boulder", "\8b\90\8aâ\82ð\95\\8e¦\82·\82é\83V\83\93\83{\83\8b\95¶\8e\9a", 1,
+ SET_IN_GAME },
#endif
+/*JP
{ "catname", "the name of your (first) cat (e.g., catname:Tabby)",
+*/
+ { "catname", "\96`\8c¯\82ð\8b\9f\82É\82·\82é(\8dÅ\8f\89\82Ì)\94L\82Ì\96¼\91O (\97á catname:\82½\82Ü)",
PL_PSIZ, DISP_IN_GAME },
+/*JP
{ "disclose", "the kinds of information to disclose at end of game",
+*/
+ { "disclose", "\83Q\81[\83\80\8fI\97¹\8e\9e\82É\8c©\82é\8fî\95ñ\82Ì\8eí\97Þ",
sizeof(flags.end_disclose) * 2, SET_IN_GAME },
+/*JP
{ "dogname", "the name of your (first) dog (e.g., dogname:Fang)", PL_PSIZ,
+*/
+ { "dogname", "\96`\8c¯\82ð\8b\9f\82É\82·\82é(\8dÅ\8f\89\82Ì)\8c¢\82Ì\96¼\91O (\97á dogname:\83|\83`)", PL_PSIZ,
DISP_IN_GAME },
+/*JP
{ "dungeon", "the symbols to use in drawing the dungeon map",
+*/
+ { "dungeon", "\83_\83\93\83W\83\87\83\93\82ð\95`\89æ\82·\82é\83V\83\93\83{\83\8b\95¶\8e\9a",
MAXDCHARS + 1, SET_IN_FILE },
+/*JP
{ "effects", "the symbols to use in drawing special effects",
+*/
+ { "effects", "\93Á\8eê\8cø\89Ê\82ð\95`\89æ\82·\82é\83V\83\93\83{\83\8b\95¶\8e\9a",
MAXECHARS + 1, SET_IN_FILE },
+/*JP
{ "font_map", "the font to use in the map window", 40,
+*/
+ { "font_map", "\83}\83b\83v\83E\83B\83\93\83h\83E\82É\8eg\97p\82·\82é\83t\83H\83\93\83g", 40,
DISP_IN_GAME }, /*WC*/
+#if 0 /*JP*/
{ "font_menu", "the font to use in menus", 40, DISP_IN_GAME }, /*WC*/
+#else
+ { "font_menu", "\83\81\83j\83\85\81[\82É\8eg\97p\82·\82é\83t\83H\83\93\83g", 40, DISP_IN_GAME }, /*WC*/
+#endif
+/*JP
{ "font_message", "the font to use in the message window", 40,
+*/
+ { "font_message", "\83\81\83b\83Z\81[\83W\83E\83B\83\93\83h\83E\82É\8eg\97p\82·\82é\83t\83H\83\93\83g", 40,
DISP_IN_GAME }, /*WC*/
+#if 0 /*JP*/
{ "font_size_map", "the size of the map font", 20, DISP_IN_GAME }, /*WC*/
+#else
+ { "font_size_map", "\83}\83b\83v\83t\83H\83\93\83g\82Ì\83T\83C\83Y", 20, DISP_IN_GAME }, /*WC*/
+#endif
+/*JP
{ "font_size_menu", "the size of the menu font", 20,
+*/
+ { "font_size_menu", "\83\81\83j\83\85\81[\83t\83H\83\93\83g\82Ì\83T\83C\83Y", 20,
DISP_IN_GAME }, /*WC*/
+/*JP
{ "font_size_message", "the size of the message font", 20,
+*/
+ { "font_size_message", "\83\81\83b\83Z\81[\83W\83t\83H\83\93\83g\82Ì\83T\83C\83Y", 20,
DISP_IN_GAME }, /*WC*/
+/*JP
{ "font_size_status", "the size of the status font", 20,
+*/
+ { "font_size_status", "\8fó\8bµ\83t\83H\83\93\83g\82Ì\83T\83C\83Y", 20,
DISP_IN_GAME }, /*WC*/
+/*JP
{ "font_size_text", "the size of the text font", 20,
+*/
+ { "font_size_text", "\83e\83L\83X\83g\83t\83H\83\93\83g\82Ì\83T\83C\83Y", 20,
DISP_IN_GAME }, /*WC*/
+/*JP
{ "font_status", "the font to use in status window", 40,
+*/
+ { "font_status", "\8fó\8bµ\83E\83B\83\93\83h\83E\82É\8eg\97p\82·\82é\83t\83H\83\93\83g", 40,
DISP_IN_GAME }, /*WC*/
+/*JP
{ "font_text", "the font to use in text windows", 40,
+*/
+ { "font_text", "\83e\83L\83X\83g\83E\83B\83\93\83h\83E\82É\8eg\97p\82·\82é\83t\83H\83\93\83g", 40,
DISP_IN_GAME }, /*WC*/
+/*JP
{ "fruit", "the name of a fruit you enjoy eating", PL_FSIZ, SET_IN_GAME },
+*/
+ { "fruit", "\8dD\95¨\82Ì\89Ê\95¨\82Ì\96¼\91O", PL_FSIZ, SET_IN_GAME },
+/*JP
{ "gender", "your starting gender (male or female)", 8, DISP_IN_GAME },
+*/
+ { "gender", "\83Q\81[\83\80\8aJ\8en\8e\9e\82Ì\90«\95Ê(male \82Ü\82½\82Í female)", 8, DISP_IN_GAME },
+/*JP
{ "horsename", "the name of your (first) horse (e.g., horsename:Silver)",
+*/
+ { "horsename", "\96`\8c¯\82ð\8b\9f\82É\82·\82é(\8dÅ\8f\89\82Ì)\94n\82Ì\96¼\91O (\97á ghoulname:\83V\83\8b\83o\81[)",
PL_PSIZ, DISP_IN_GAME },
+#if 0 /*JP*/
{ "map_mode", "map display mode under Windows", 20, DISP_IN_GAME }, /*WC*/
+#else
+ { "map_mode", "\83E\83B\83\93\83h\83E\95\\8e¦\8e\9e\82Ì\83}\83b\83v\82Ì\95\\8e¦\83\82\81[\83h", 20, DISP_IN_GAME }, /*WC*/
+#endif
+/*JP
{ "menustyle", "user interface for object selection", MENUTYPELEN,
+*/
+ { "menustyle", "\83I\83u\83W\83F\83N\83g\82ð\91I\91ð\82·\82é\82Æ\82«\82Ì\83\86\81[\83U\81[\83C\83\93\83^\83t\83F\81[\83X", MENUTYPELEN,
SET_IN_GAME },
+/*JP
{ "menu_deselect_all", "deselect all items in a menu", 4, SET_IN_FILE },
+*/
+ { "menu_deselect_all", "\91S\82Ä\82Ì\83A\83C\83e\83\80\82ð\94ñ\91I\91ð", 4, SET_IN_FILE },
+/*JP
{ "menu_deselect_page", "deselect all items on this page of a menu", 4,
+*/
+ { "menu_deselect_page", "\8c»\8dÝ\95\\8e¦\82³\82ê\82Ä\82¢\82é\83y\81[\83W\82Ì\83A\83C\83e\83\80\82ð\94ñ\91I\91ð", 4,
SET_IN_FILE },
+/*JP
{ "menu_first_page", "jump to the first page in a menu", 4, SET_IN_FILE },
+*/
+ { "menu_first_page", "\83\81\83j\83\85\81[\82Ì\8dÅ\8f\89\82Ì\83y\81[\83W\82Ö", 4, SET_IN_FILE },
+/*JP
{ "menu_headings", "text attribute for menu headings", 9, SET_IN_GAME },
+*/
+ { "menu_headings", "\8b\92²\81C\94½\93]\82Ü\82½\82Í\89º\90ü\82Å\8eí\97Þ\82ð\95\\8e¦\82·\82é", 9, SET_IN_GAME },
+/*JP
{ "menu_invert_all", "invert all items in a menu", 4, SET_IN_FILE },
+*/
+ { "menu_invert_all", "\91S\82Ä\82Ì\83A\83C\83e\83\80\82ð\94½\93]", 4, SET_IN_FILE },
+/*JP
{ "menu_invert_page", "invert all items on this page of a menu", 4,
+*/
+ { "menu_invert_page", "\8c»\8dÝ\95\\8e¦\82³\82ê\82Ä\82¢\82é\83y\81[\83W\82Ì\83A\83C\83e\83\80\82ð\94½\93]",
SET_IN_FILE },
+/*JP
{ "menu_last_page", "jump to the last page in a menu", 4, SET_IN_FILE },
+*/
+ { "menu_last_page", "\83\81\83j\83\85\81[\82Ì\8dÅ\8cã\82Ì\83y\81[\83W\82Ö", 4, SET_IN_FILE },
+/*JP
{ "menu_next_page", "goto the next menu page", 4, SET_IN_FILE },
+*/
+ { "menu_next_page", "\8e\9f\82Ì\83\81\83j\83\85\81[\82Ì\83y\81[\83W\82Ö", 4, SET_IN_FILE },
+/*JP
{ "menu_previous_page", "goto the previous menu page", 4, SET_IN_FILE },
+*/
+ { "menu_previous_page", "\91O\82Ì\83\81\83j\83\85\81[\82Ì\83y\81[\83W\82Ö", 4, SET_IN_FILE },
+/*JP
{ "menu_search", "search for a menu item", 4, SET_IN_FILE },
+*/
+ { "menu_search", "\83\81\83j\83\85\81[\82Ì\8c\9f\8dõ", 4, SET_IN_FILE },
+/*JP
{ "menu_select_all", "select all items in a menu", 4, SET_IN_FILE },
+*/
+ { "menu_select_all", "\91S\82Ä\82Ì\83A\83C\83e\83\80\82ð\91I\91ð", 4, SET_IN_FILE },
+/*JP
{ "menu_select_page", "select all items on this page of a menu", 4,
+*/
+ { "menu_select_page", "\8c»\8dÝ\95\\8e¦\82³\82ê\82Ä\82¢\82é\91S\82Ä\82Ì\83A\83C\83e\83\80\82ð\91I\91ð", 4,
SET_IN_FILE },
+/*JP
{ "monsters", "the symbols to use for monsters", MAXMCLASSES,
+*/
+ { "monsters", "\83\82\83\93\83X\83^\81[\82É\8eg\97p\82³\82ê\82é\83V\83\93\83{\83\8b\95¶\8e\9a", MAXMCLASSES,
SET_IN_FILE },
+/*JP
{ "msghistory", "number of top line messages to save", 5, DISP_IN_GAME },
+*/
+ { "msghistory", "\90æ\93ª\8ds\82É\95\\8e¦\82³\82ê\82½\83\81\83b\83Z\81[\83W\97\9a\97ð\82Ì\95Û\91¶\90\94", 5, DISP_IN_GAME },
#ifdef TTY_GRAPHICS
+/*JP
{ "msg_window", "the type of message window required", 1, SET_IN_GAME },
+*/
+ {"msg_window", "\83\81\83b\83Z\81[\83W\83E\83B\83\93\83h\83E\82Ì\83^\83C\83v\82ð\90Ý\92è",1, SET_IN_GAME },
#else
+/*JP
{ "msg_window", "the type of message window required", 1, SET_IN_FILE },
+*/
+ {"msg_window", "\83\81\83b\83Z\81[\83W\83E\83B\83\93\83h\83E\82Ì\83^\83C\83v\82ð\90Ý\92è", 1, SET_IN_FILE },
#endif
+/*JP
{ "name", "your character's name (e.g., name:Merlin-W)", PL_NSIZ,
+*/
+ { "name", "\82 \82È\82½\82Ì\96¼\91O (\97á name:\83}\81[\83\8a\83\93-W)", PL_NSIZ,
DISP_IN_GAME },
+/*JP
{ "number_pad", "use the number pad for movement", 1, SET_IN_GAME },
+*/
+ { "number_pad", "\83i\83\93\83o\81[\83p\83b\83h\82ð\8eg\97p\82·\82é", 1, SET_IN_GAME },
+/*JP
{ "objects", "the symbols to use for objects", MAXOCLASSES, SET_IN_FILE },
+*/
+ { "objects", "\83A\83C\83e\83\80\82É\8eg\97p\82³\82ê\82é\83V\83\93\83{\83\8b\95¶\8e\9a", MAXOCLASSES, SET_IN_FILE },
+/*JP
{ "packorder", "the inventory order of the items in your pack",
+*/
+ { "packorder", "\94w\95\89\82¢\91Ü\93à\82Ì\95¨\82Ì\8f\87\94Ô",
MAXOCLASSES, SET_IN_GAME },
#ifdef CHANGE_COLOR
{ "palette",
#ifndef WIN32
+/*JP
"palette (00c/880/-fff is blue/yellow/reverse white)", 15,
+*/
+ "\83p\83\8c\83b\83g (00c/880/-fff\82Í\82»\82ê\82¼\82ê\90Â/\89©/\94½\93]\94\92\82ð\8e¦\82·)", 15,
SET_IN_GAME },
#else
+/*JP
"palette (adjust an RGB color in palette (color-R-G-B)", 15,
+*/
+ "\83p\83\8c\83b\83g (\83p\83\8c\83b\83g\82ÌRGB\90F\82ð\92²\90®\82·\82é (\90F-R-G-B)", 15,
SET_IN_FILE },
#endif
#if defined(MAC)
+/*JP
{ "hicolor", "same as palette, only order is reversed", 15, SET_IN_FILE },
+*/
+ { "hicolor", "\83p\83\8c\83b\83g\82ª\93¯\82¶\82Æ\82«\81A\8ew\8e¦\82µ\82½\82à\82Ì\82¾\82¯\94½\93]\82³\82¹\82é", 15, SET_IN_FILE },
#endif
#endif
+#if 0 /*JP*/
{ "paranoid_confirmation", "extra prompting in certain situations", 28,
SET_IN_GAME },
+#else
+ { "paranoid_confirmation", "\88ê\95\94\82Ì\8fó\8bµ\82Å\92Ç\89Á\82Ì\8am\94F\82ð\82·\82é", 28,
+ SET_IN_GAME },
+#endif
+/*JP
{ "pettype", "your preferred initial pet type", 4, DISP_IN_GAME },
+*/
+ { "pettype", "\82 \82È\82½\82Ì\91I\91ð\82µ\82½\8f\89\8aú\83y\83b\83g\82Ì\8eí\97Þ", 4, DISP_IN_GAME },
+/*JP
{ "pickup_burden", "maximum burden picked up before prompt", 20,
+*/
+ { "pickup_burden", "\8fE\82¤\82Æ\82«\82É\8dÅ\91å\89×\8fd\82É\82È\82é\8eè\91O\82Å\8am\94F\82·\82é", 20,
SET_IN_GAME },
+/*JP
{ "pickup_types", "types of objects to pick up automatically",
+*/
+ { "pickup_types", "\8e©\93®\82Å\8fE\82¢\82 \82°\82é\95¨\82Ì\83V\83\93\83{\83\8b",
MAXOCLASSES, SET_IN_GAME },
+#if 0 /*JP*/
{ "pile_limit", "threshold for \"there are many objects here\"", 24,
SET_IN_GAME },
+#else
+ { "pile_limit", "\81u\82±\82±\82É\82Í\82½\82\82³\82ñ\82Ì\82à\82Ì\82ª\82 \82é\81v\82Ì\82µ\82«\82¢\92l", 24,
+ SET_IN_GAME },
+#endif
+#if 0 /*JP*/
{ "playmode", "normal play, non-scoring explore mode, or debug mode", 8,
DISP_IN_GAME },
+#else
+ { "playmode", "\92Ê\8fí\83\82\81[\83h\81C\92T\8c\9f\83\82\81[\83h\81C\83f\83o\83b\83O\83\82\81[\83h\82Ì\82¢\82¸\82ê\82©", 8,
+ DISP_IN_GAME },
+#endif
+/*JP
{ "player_selection", "choose character via dialog or prompts", 12,
+*/
+ { "player_selection", "\83L\83\83\83\89\83N\83^\81[\91I\91ð\82É\83_\83C\83A\83\8d\83O\82â\8am\94F\89æ\96Ê\82ð\8eg\82¤", 12,
DISP_IN_GAME },
+/*JP
{ "race", "your starting race (e.g., Human, Elf)", PL_CSIZ,
+*/
+ { "race", "\83Q\81[\83\80\8aJ\8en\8e\9e\82Ì\8eí\91° (\97á Human, Elf)", PL_CSIZ,
DISP_IN_GAME },
+/*JP
{ "role", "your starting role (e.g., Barbarian, Valkyrie)", PL_CSIZ,
+*/
+ { "role", "\83Q\81[\83\80\8aJ\8en\8e\9e\82Ì\90E\8bÆ (\97á Barbarian, Valkyrie)", PL_CSIZ,
DISP_IN_GAME },
+/*JP
{ "runmode", "display frequency when `running' or `travelling'",
+*/
+ { "runmode", "\83g\83\89\83x\83\8b\83R\83}\83\93\83h\93\99\82Å\82Ì\98A\91±\88Ú\93®\8e\9e\82Ì\95`\89æ\95p\93x",
sizeof "teleport", SET_IN_GAME },
+/*JP
{ "scores", "the parts of the score list you wish to see", 32,
+*/
+ { "scores", "\83Q\81[\83\80\8fI\97¹\8e\9e\82É\8c©\82é\83X\83R\83A\82Ì\8eí\97Þ", 32,
SET_IN_GAME },
+/*JP
{ "scroll_amount", "amount to scroll map when scroll_margin is reached",
+*/
+ { "scroll_amount", "scroll_margin\82É\93Í\82¢\82½\82Æ\82«\82Ì\83}\83b\83v\83X\83N\83\8d\81[\83\8b\97Ê",
20, DISP_IN_GAME }, /*WC*/
+/*JP
{ "scroll_margin", "scroll map when this far from the edge", 20,
+*/
+ { "scroll_margin", "\83}\83b\83v\92[\82©\82ç\82Ì\83}\83b\83v\83X\83N\83\8d\81[\83\8b\8aJ\8en\8b\97\97£", 20,
DISP_IN_GAME }, /*WC*/
+/*JP
{ "sortloot", "sort object selection lists by description", 4,
+*/
+ { "sortloot", "\95¨\91Ì\91I\91ð\83\8a\83X\83g\82ð\90à\96¾\82Å\83\\81[\83g\82·\82é", 4,
SET_IN_GAME },
#ifdef MSDOS
+/*JP
{ "soundcard", "type of sound card to use", 20, SET_IN_FILE },
+*/
+ { "soundcard", "\8eg\97p\82µ\82Ä\82¢\82é\83T\83E\83\93\83h\83J\81[\83h\82Ì\8eí\97Þ", 20, SET_IN_FILE },
+#endif
+#ifdef STATUS_HILITES
+ { "statushilites",
+ "0=no status highlighting, N=show highlights for N turns",
+ 20, SET_IN_GAME },
+#else
+ { "statushilites", "highlight control", 20, SET_IN_FILE },
#endif
+#if 0 /*JP*/
{ "symset", "load a set of display symbols from the symbols file", 70,
SET_IN_GAME },
+#else
+ { "symset", "symbols\83t\83@\83C\83\8b\82©\82ç\95\\8e¦\83V\83\93\83{\83\8b\82Ì\90Ý\92è\82ð\93Ç\82Ý\8d\9e\82Þ", 70,
+ SET_IN_GAME },
+#endif
+#if 0 /*JP*/
{ "roguesymset",
"load a set of rogue display symbols from the symbols file", 70,
SET_IN_GAME },
+#else
+ { "roguesymset",
+ "symbols\83t\83@\83C\83\8b\82©\82ç\83\8d\81[\83O\83\8c\83x\83\8b\82Ì\95\\8e¦\83V\83\93\83{\83\8b\82Ì\90Ý\92è\82ð\93Ç\82Ý\8d\9e\82Þ", 70,
+ SET_IN_GAME },
+#endif
+#ifdef WIN32
+/*JP
+ { "subkeyvalue", "override keystroke value", 7, SET_IN_FILE },
+*/
+ {"subkeyvalue", "\83L\81[\83}\83b\83s\83\93\83O\82ð\95Ï\8dX\82·\82é", 7, SET_IN_FILE },
+#endif
+/*JP
{ "suppress_alert", "suppress alerts about version-specific features", 8,
+*/
+ { "suppress_alert", "\83o\81[\83W\83\87\83\93\8aÔ\82Ì\88á\82¢\82É\8aÖ\82·\82é\8cx\8d\90\83\81\83b\83Z\81[\83W\82Ì\96³\8cø\89»", 8,
SET_IN_GAME },
+#if 0 /*JP*/
{ "tile_width", "width of tiles", 20, DISP_IN_GAME }, /*WC*/
+#else
+ { "tile_width", "\83^\83C\83\8b\82Ì\95\9d", 20, DISP_IN_GAME }, /*WC*/
+#endif
+#if 0 /*JP*/
{ "tile_height", "height of tiles", 20, DISP_IN_GAME }, /*WC*/
+#else
+ { "tile_height", "\83^\83C\83\8b\82Ì\8d\82\82³", 20, DISP_IN_GAME }, /*WC*/
+#endif
+#if 0 /*JP*/
{ "tile_file", "name of tile file", 70, DISP_IN_GAME }, /*WC*/
+#else
+ { "tile_file", "\83^\83C\83\8b\83t\83@\83C\83\8b\82Ì\96¼\91O", 70, DISP_IN_GAME }, /*WC*/
+#endif
+/*JP
{ "traps", "the symbols to use in drawing traps", MAXTCHARS + 1,
+*/
+ { "traps", "ã©\82ð\95`\89æ\82·\82é\83V\83\93\83{\83\8b\95¶\8e\9a", MAXTCHARS + 1,
SET_IN_FILE },
+/*JP
{ "vary_msgcount", "show more old messages at a time", 20,
+*/
+ { "vary_msgcount", "\88ê\93x\82É\95\\8e¦\82·\82é\83\81\83b\83Z\81[\83W\82Ì\90\94", 20,
DISP_IN_GAME }, /*WC*/
#ifdef MSDOS
+/*JP
{ "video", "method of video updating", 20, SET_IN_FILE },
+*/
+ { "video", "\8eg\97p\82·\82é\83r\83f\83I\83\82\81[\83h\82ð\90Ý\92è\82·\82é", 20, SET_IN_FILE },
#endif
#ifdef VIDEOSHADES
+/*JP
{ "videocolors", "color mappings for internal screen routines", 40,
+*/
+ { "videocolors", "\93à\91 \83X\83N\83\8a\81[\83\93\83\8b\81[\83`\83\93\97p\82Ì\83J\83\89\81[\83}\83b\83v\82ð\97p\82¢\82é", 40,
DISP_IN_GAME },
+/*JP
{ "videoshades", "gray shades to map to black/gray/white", 32,
+*/
+ { "videoshades", "\95\\8e¦\82É\83O\83\8c\83C\83X\83P\81[\83\8b\82ð\97p\82¢\82é", 32,
DISP_IN_GAME },
#endif
-#ifdef WIN32
- { "subkeyvalue", "override keystroke value", 7, SET_IN_FILE },
-#endif
+ { "whatis_coord", "show coordinates when auto-describing cursor position",
+ 1, SET_IN_GAME },
+ { "whatis_filter",
+ "filter coordinate locations when targeting next or previous",
+ 1, SET_IN_GAME },
+#if 0 /*JP*/
{ "windowcolors", "the foreground/background colors of windows", /*WC*/
80, DISP_IN_GAME },
+#else
+ { "windowcolors", "\83E\83B\83\93\83h\83E\82ð\8ew\92è\82µ\82½\91O\8ci\90F/\94w\8ci\90F\82Å\95\\8e¦\82·\82é", /*WC*/
+ 80, DISP_IN_GAME },
+#endif
+/*JP
{ "windowtype", "windowing system to use", WINTYPELEN, DISP_IN_GAME },
+*/
+ { "windowtype", "\8eg\97p\82·\82é\83E\83C\83\93\83h\83E\83V\83X\83e\83\80", WINTYPELEN, DISP_IN_GAME },
#ifdef WINCHAIN
+/*JP
{ "windowchain", "window processor to use", WINTYPELEN, SET_IN_SYS },
+*/
+ { "windowchain", "\8eg\97p\82·\82é\83E\83B\83\93\83h\83E\83v\83\8d\83Z\83b\83T", WINTYPELEN, SET_IN_SYS },
#endif
#ifdef BACKWARD_COMPAT
+/*JP
{ "DECgraphics", "load DECGraphics display symbols", 70, SET_IN_FILE },
+*/
+ { "DECgraphics", "DECGraphics\95\\8e¦\83V\83\93\83{\83\8b\82ð\93Ç\82Ý\8d\9e\82Þ", 70, SET_IN_FILE },
+/*JP
{ "IBMgraphics", "load IBMGraphics display symbols", 70, SET_IN_FILE },
+*/
+ { "IBMgraphics", "IBMGraphics\95\\8e¦\83V\83\93\83{\83\8b\82ð\93Ç\82Ý\8d\9e\82Þ", 70, SET_IN_FILE },
#ifdef MAC_GRAPHICS_ENV
+/*JP
{ "Macgraphics", "load MACGraphics display symbols", 70, SET_IN_FILE },
+*/
+ { "Macgraphics", "MACGraphics\95\\8e¦\83V\83\93\83{\83\8b\82ð\93Ç\82Ý\8d\9e\82Þ", 70, SET_IN_FILE },
+#endif
#endif
+#if 1 /*JP*/
+ { "kcode", "\92[\96\96\82Ì\8a¿\8e\9a\83R\81[\83h,", 4, SET_IN_FILE },
#endif
{ (char *) 0, (char *) 0, 0, 0 }
};
#else /* use rest of file */
+extern char configfile[]; /* for messages */
+
extern struct symparse loadsyms[];
static boolean need_redraw; /* for doset() */
typedef struct {
const char *name;
char cmd;
+ const char *desc;
} menu_cmd_t;
-#define NUM_MENU_CMDS 11
-static const menu_cmd_t default_menu_cmd_info[NUM_MENU_CMDS] = {
-/* 0*/ { "menu_first_page", MENU_FIRST_PAGE },
- { "menu_last_page", MENU_LAST_PAGE },
- { "menu_next_page", MENU_NEXT_PAGE },
- { "menu_previous_page", MENU_PREVIOUS_PAGE },
- { "menu_select_all", MENU_SELECT_ALL },
-/* 5*/ { "menu_deselect_all", MENU_UNSELECT_ALL },
- { "menu_invert_all", MENU_INVERT_ALL },
- { "menu_select_page", MENU_SELECT_PAGE },
- { "menu_deselect_page", MENU_UNSELECT_PAGE },
- { "menu_invert_page", MENU_INVERT_PAGE },
-/*10*/ { "menu_search", MENU_SEARCH },
+static const menu_cmd_t default_menu_cmd_info[] = {
+ { "menu_first_page", MENU_FIRST_PAGE, "Go to first page" },
+ { "menu_last_page", MENU_LAST_PAGE, "Go to last page" },
+ { "menu_next_page", MENU_NEXT_PAGE, "Go to next page" },
+ { "menu_previous_page", MENU_PREVIOUS_PAGE, "Go to previous page" },
+ { "menu_select_all", MENU_SELECT_ALL, "Select all items" },
+ { "menu_deselect_all", MENU_UNSELECT_ALL, "Unselect all items" },
+ { "menu_invert_all", MENU_INVERT_ALL, "Invert selection" },
+ { "menu_select_page", MENU_SELECT_PAGE, "Select items in current page" },
+ { "menu_deselect_page", MENU_UNSELECT_PAGE,
+ "Unselect items in current page" },
+ { "menu_invert_page", MENU_INVERT_PAGE, "Invert current page selection" },
+ { "menu_search", MENU_SEARCH, "Search and toggle matching items" },
};
/*
static boolean initial, from_file;
-STATIC_DCL void FDECL(doset_add_menu, (winid, const char *, int));
STATIC_DCL void FDECL(nmcpy, (char *, const char *, int));
STATIC_DCL void FDECL(escapes, (const char *, char *));
STATIC_DCL void FDECL(rejectoption, (const char *));
-STATIC_DCL void FDECL(badoption, (const char *));
STATIC_DCL char *FDECL(string_for_opt, (char *, BOOLEAN_P));
STATIC_DCL char *FDECL(string_for_env_opt, (const char *, char *, BOOLEAN_P));
STATIC_DCL void FDECL(bad_negation, (const char *, BOOLEAN_P));
STATIC_DCL int FDECL(change_inv_order, (char *));
-STATIC_DCL void FDECL(oc_to_str, (char *, char *));
+STATIC_DCL boolean FDECL(warning_opts, (char *, const char *));
STATIC_DCL int FDECL(feature_alert_opts, (char *, const char *));
-STATIC_DCL const char *FDECL(get_compopt_value, (const char *, char *));
-STATIC_DCL boolean FDECL(special_handling, (const char *,
- BOOLEAN_P, BOOLEAN_P));
-STATIC_DCL void FDECL(warning_opts, (char *, const char *));
STATIC_DCL boolean FDECL(duplicate_opt_detection, (const char *, int));
STATIC_DCL void FDECL(complain_about_duplicate, (const char *, int));
-STATIC_OVL void FDECL(wc_set_font_name, (int, char *));
-STATIC_OVL int FDECL(wc_set_window_colors, (char *));
-STATIC_OVL boolean FDECL(is_wc_option, (const char *));
-STATIC_OVL boolean FDECL(wc_supported, (const char *));
-STATIC_OVL boolean FDECL(is_wc2_option, (const char *));
-STATIC_OVL boolean FDECL(wc2_supported, (const char *));
-STATIC_DCL void FDECL(remove_autopickup_exception,
- (struct autopickup_exception *));
-STATIC_OVL int FDECL(count_ape_maps, (int *, int *));
STATIC_DCL const char *FDECL(attr2attrname, (int));
-STATIC_DCL int NDECL(query_color);
-STATIC_DCL int NDECL(query_msgtype);
-STATIC_DCL int FDECL(query_attr, (const char *));
STATIC_DCL const char * FDECL(msgtype2name, (int));
+STATIC_DCL int NDECL(query_msgtype);
STATIC_DCL boolean FDECL(msgtype_add, (int, char *));
STATIC_DCL void FDECL(free_one_msgtype, (int));
STATIC_DCL int NDECL(msgtype_count);
+STATIC_DCL boolean FDECL(test_regex_pattern, (const char *, const char *));
STATIC_DCL boolean FDECL(add_menu_coloring_parsed, (char *, int, int));
STATIC_DCL void FDECL(free_one_menu_coloring, (int));
STATIC_DCL int NDECL(count_menucolors);
+STATIC_DCL boolean FDECL(parse_role_opts, (BOOLEAN_P, const char *,
+ char *, char **));
+
+STATIC_DCL void FDECL(oc_to_str, (char *, char *));
+STATIC_DCL void FDECL(doset_add_menu, (winid, const char *, int));
+STATIC_DCL void FDECL(opts_add_others, (winid, const char *, int,
+ char *, int));
STATIC_DCL int FDECL(handle_add_list_remove, (const char *, int));
+STATIC_DCL boolean FDECL(special_handling, (const char *,
+ BOOLEAN_P, BOOLEAN_P));
+STATIC_DCL const char *FDECL(get_compopt_value, (const char *, char *));
+STATIC_DCL void FDECL(remove_autopickup_exception,
+ (struct autopickup_exception *));
+STATIC_DCL int FDECL(count_ape_maps, (int *, int *));
+
+STATIC_DCL boolean FDECL(is_wc_option, (const char *));
+STATIC_DCL boolean FDECL(wc_supported, (const char *));
+STATIC_DCL boolean FDECL(is_wc2_option, (const char *));
+STATIC_DCL boolean FDECL(wc2_supported, (const char *));
+STATIC_DCL void FDECL(wc_set_font_name, (int, char *));
+STATIC_DCL int FDECL(wc_set_window_colors, (char *));
void
reglyph_darkroom()
if (!p || (q && q < p))
p = q;
- while (p && p > user_string && isspace((uchar) * (p - 1)))
- p--;
- if (p)
+ if (p) {
+ /* 'user_string' hasn't necessarily been through mungspaces()
+ so might have tabs or consecutive spaces */
+ while (p > user_string && isspace((uchar) *(p - 1)))
+ p--;
len = (int) (p - user_string);
+ }
}
return (boolean) (len >= min_length
#ifdef SYSCF_FILE
/* If SYSCF_FILE is specified, it _must_ exist... */
assure_syscf_file();
+ config_error_init(TRUE, SYSCF_FILE, FALSE);
+
/* ... and _must_ parse correctly. */
if (!read_config_file(SYSCF_FILE, SET_IN_SYS)) {
- raw_printf("Error(s) found in SYSCF_FILE, quitting.");
- terminate(EXIT_FAILURE);
+ if (config_error_done())
+ nh_terminate(EXIT_FAILURE);
}
+ config_error_done();
/*
* TODO [maybe]: parse the sysopt entries which are space-separated
* lists of usernames into arrays with one name per element.
*/
#endif
-#endif
+#endif /* SYSCF */
initoptions_finish();
}
iflags.prevmsg_window = 's';
#endif
iflags.menu_headings = ATR_INVERSE;
+ iflags.getpos_coords = GPCOORDS_NONE;
/* hero's role, race, &c haven't been chosen yet */
- flags.initrole = flags.initrace = flags.initgend = flags.initalign =
- ROLE_NONE;
+ flags.initrole = flags.initrace = flags.initgend = flags.initalign
+ = ROLE_NONE;
/* Set the default monster and object class symbols. */
init_symbols();
iflags.travelcc.x = iflags.travelcc.y = -1;
+ /* for "special achievement" tracking (see obj.h,
+ create_object(sp_lev.c), addinv_core1(invent.c) */
+ iflags.mines_prize_type = LUCKSTONE;
+ iflags.soko_prize_type1 = BAG_OF_HOLDING;
+ iflags.soko_prize_type2 = AMULET_OF_REFLECTION;
+
/* assert( sizeof flags.inv_order == sizeof def_inv_order ); */
(void) memcpy((genericptr_t) flags.inv_order,
(genericptr_t) def_inv_order, sizeof flags.inv_order);
if (*opts == '@')
opts++; /* @filename */
/* looks like a filename */
- if (strlen(opts) < BUFSZ / 2)
+ if (strlen(opts) < BUFSZ / 2) {
+ config_error_init(TRUE, opts, CONFIG_ERROR_SECURE);
read_config_file(opts, SET_IN_FILE);
+ config_error_done();
+ }
} else {
+ config_error_init(TRUE, (char *) 0, FALSE);
read_config_file((char *) 0, SET_IN_FILE);
+ config_error_done();
/* let the total length of options be long;
* parseoptions() will check each individually
*/
- parseoptions(opts, TRUE, FALSE);
+ config_error_init(FALSE, "NETHACKOPTIONS", FALSE);
+ (void) parseoptions(opts, TRUE, FALSE);
+ config_error_done();
}
} else
-#endif
+#endif /* !MAC */
+ /*else*/ {
+ config_error_init(TRUE, (char *) 0, FALSE);
read_config_file((char *) 0, SET_IN_FILE);
+ config_error_done();
+ }
(void) fruitadd(pl_fruit, (struct fruit *) 0);
/*
if (iflags.bouldersym)
update_bouldersym();
reglyph_darkroom();
+
+#ifdef STATUS_HILITES
+ /*
+ * A multi-interface binary might only support status highlighting
+ * for some of the interfaces; check whether we asked for it but are
+ * using one which doesn't.
+ */
+ if (iflags.hilite_delta && !wc2_supported("statushilites")) {
+ raw_printf("Status highlighting not supported for %s interface.",
+ windowprocs.name);
+ iflags.hilite_delta = 0;
+ }
+#endif
return;
}
* has the effect of 'meta'-ing the value which follows (so that the
* alternate character set will be enabled).
*
+ * X normal key X
+ * ^X control-X
+ * \mX meta-X
+ *
* For 3.4.3 and earlier, input ending with "\M", backslash, or caret
* prior to terminating '\0' would pull that '\0' into the output and then
* keep processing past it, potentially overflowing the output buffer.
} else if (*cp == '^') { /* expand control-character syntax */
cval = (*++cp & 0x1f);
++cp;
- /* remaining cases are all for backslash and we know cp[1] is not
- * \0 */
+
+ /* remaining cases are all for backslash; we know cp[1] is not \0 */
} else if (index(dec, cp[1])) {
++cp; /* move past backslash to first digit */
do {
const char *optname;
{
#ifdef MICRO
- pline("\"%s\" settable only from %s.", optname, lastconfigfile);
+ pline("\"%s\" settable only from %s.", optname, configfile);
#else
pline("%s can be set only from NETHACKOPTIONS or %s.", optname,
- lastconfigfile);
+ configfile);
#endif
}
-STATIC_OVL void
-badoption(opts)
-const char *opts;
-{
- if (!initial) {
- if (!strncmp(opts, "h", 1) || !strncmp(opts, "?", 1))
- option_help();
- else
- pline("Bad syntax: %s. Enter \"?g\" for help.", opts);
- return;
- }
-#ifdef MAC
- else
- return;
-#endif
+/*
- if (from_file)
- raw_printf("Bad syntax in OPTIONS in %s: %s%s.\n", lastconfigfile,
-#ifdef WIN32
- "\n",
-#else
- "",
-#endif
- opts);
- else
- raw_printf("Bad syntax in NETHACKOPTIONS: %s%s.\n",
-#ifdef WIN32
- "\n",
-#else
- "",
-#endif
- opts);
- wait_synch();
-}
+# errors:
+OPTIONS=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+OPTIONS
+OPTIONS=
+MSGTYPE=stop"You swap places with "
+MSGTYPE=st.op "You swap places with "
+MSGTYPE=stop "You swap places with \"
+MENUCOLOR=" blessed "green&none
+MENUCOLOR=" holy " = green&reverse
+MENUCOLOR=" cursed " = red&uline
+MENUCOLOR=" unholy " = reed
+OPTIONS=!legacy:true,fooo
+OPTIONS=align:!pin
+OPTIONS=gender
+
+*/
STATIC_OVL char *
string_for_opt(opts, val_optional)
if (!colon || !*++colon) {
if (!val_optional)
- badoption(opts);
+ config_error_add("Missing parameter for '%s'", opts);
return (char *) 0;
}
return colon;
char *op;
{
int oc_sym, num;
- char *sp, buf[BUFSZ];
+ char *sp, buf[QBUFSZ];
+ int retval = 1;
num = 0;
- /* !!!! probably unnecessary with gold as normal inventory */
+ if (!index(op, GOLD_SYM))
+ buf[num++] = COIN_CLASS;
for (sp = op; *sp; sp++) {
+ boolean fail = FALSE;
oc_sym = def_char_to_objclass(*sp);
/* reject bad or duplicate entries */
- if (oc_sym == MAXOCLASSES || oc_sym == RANDOM_CLASS
- || oc_sym == ILLOBJ_CLASS || !index(flags.inv_order, oc_sym)
- || index(sp + 1, *sp))
- return 0;
+ if (oc_sym == MAXOCLASSES) { /* not an object class char */
+ config_error_add("Not an object class '%c'", *sp);
+ retval = 0;
+ fail = TRUE;
+ } else if (!index(flags.inv_order, oc_sym)) {
+ /* VENOM_CLASS, RANDOM_CLASS, and ILLOBJ_CLASS are excluded
+ because they aren't in def_inv_order[] so don't make it
+ into flags.inv_order, hence always fail this index() test */
+ config_error_add("Object class '%c' not allowed", *sp);
+ retval = 0;
+ fail = TRUE;
+ } else if (index(sp + 1, *sp)) {
+ config_error_add("Duplicate object class '%c'", *sp);
+ retval = 0;
+ fail = TRUE;
+ }
/* retain good ones */
- buf[num++] = (char) oc_sym;
+ if (!fail)
+ buf[num++] = (char) oc_sym;
}
buf[num] = '\0';
/* fill in any omitted classes, using previous ordering */
for (sp = flags.inv_order; *sp; sp++)
- if (!index(buf, *sp)) {
- buf[num++] = *sp;
- buf[num] = '\0'; /* explicitly terminate for next index() */
- }
+ if (!index(buf, *sp))
+ (void) strkitten(&buf[num++], *sp);
+ buf[MAXOCLASSES - 1] = '\0';
Strcpy(flags.inv_order, buf);
- return 1;
+ return retval;
}
-STATIC_OVL void
+STATIC_OVL boolean
warning_opts(opts, optype)
register char *opts;
const char *optype;
int length, i;
if (!(opts = string_for_env_opt(optype, opts, FALSE)))
- return;
+ return FALSE;
escapes(opts, opts);
length = (int) strlen(opts);
: opts[i] ? (uchar) opts[i]
: def_warnsyms[i].sym;
assign_warnings(translate);
+ return TRUE;
}
void
const char *optn;
{
char buf[BUFSZ];
- boolean rejectver = FALSE;
unsigned long fnv = get_feature_notice_ver(op); /* version.c */
if (fnv == 0L)
return 0;
- if (fnv > get_current_feature_ver())
- rejectver = TRUE;
- else
- flags.suppress_alert = fnv;
- if (rejectver) {
+ if (fnv > get_current_feature_ver()) {
if (!initial) {
You_cant("disable new feature alerts for future versions.");
} else {
- Sprintf(buf,
- "\n%s=%s Invalid reference to a future version ignored",
- optn, op);
- badoption(buf);
+ config_error_add(
+ "%s=%s Invalid reference to a future version ignored",
+ optn, op);
}
return 0;
}
+
+ flags.suppress_alert = fnv;
if (!initial) {
Sprintf(buf, "%lu.%lu.%lu", FEATURE_NOTICE_VER_MAJ,
FEATURE_NOTICE_VER_MIN, FEATURE_NOTICE_VER_PATCH);
/*-- ON --*/
if (iflags.opt_booldup)
impossible("iflags.opt_booldup already on (memory leak)");
- iflags.opt_booldup = (int *) alloc(SIZE(boolopt) * sizeof(int));
+ iflags.opt_booldup = (int *) alloc(SIZE(boolopt) * sizeof (int));
optptr = iflags.opt_booldup;
for (k = 0; k < SIZE(boolopt); ++k)
*optptr++ = 0;
if (iflags.opt_compdup)
impossible("iflags.opt_compdup already on (memory leak)");
- iflags.opt_compdup = (int *) alloc(SIZE(compopt) * sizeof(int));
+ iflags.opt_compdup = (int *) alloc(SIZE(compopt) * sizeof (int));
optptr = iflags.opt_compdup;
for (k = 0; k < SIZE(compopt); ++k)
*optptr++ = 0;
* For now just return.
*/
#else /* !MAC */
- raw_printf("\nWarning - %s option specified multiple times: %s.\n",
- iscompound ? "compound" : "boolean", opts);
- wait_synch();
+ config_error_add("%s option specified multiple times: %s",
+ iscompound ? "compound" : "boolean", opts);
#endif /* ?MAC */
return;
}
takes precedence and "all" isn't present in the interactive menu,
and "d"ie vs "d"eath, synonyms for each other so doesn't matter;
(also "p"ray vs "P"aranoia, "pray" takes precedence since "Paranoia"
- is just a synonym for "Confirm") */
+ is just a synonym for "Confirm"); "b"ones vs "br"eak-wand, the
+ latter requires at least two letters; "wand"-break vs "Were"-change,
+ both require at least two letters during config processing and use
+ case-senstivity for 'O's interactive menu */
{ PARANOID_CONFIRM, "Confirm", 1, "Paranoia", 2,
"for \"yes\" confirmations, require \"no\" to reject" },
{ PARANOID_QUIT, "quit", 1, "explore", 1,
"yes vs y to save bones data when dying in debug mode" },
{ PARANOID_HIT, "attack", 1, "hit", 1,
"yes vs y to attack a peaceful monster" },
+ { PARANOID_BREAKWAND, "wand-break", 2, "break-wand", 2,
+ "yes vs y to break a wand via (a)pply" },
+ { PARANOID_WERECHANGE, "Were-change", 2, (const char *) 0, 0,
+ "yes vs y to change form when lycanthropy is controllable" },
{ PARANOID_PRAY, "pray", 1, 0, 0,
"y to pray (supersedes old \"prayconfirm\" option)" },
{ PARANOID_REMOVE, "Remove", 1, "Takeoff", 1,
"always pick from inventory for Remove and Takeoff" },
- { PARANOID_BREAKWAND, "wand", 1, "breakwand", 2,
- "yes vs y to break a wand" },
/* for config file parsing; interactive menu skips these */
{ 0, "none", 4, 0, 0, 0 }, /* require full word match */
{ ~0, "all", 3, 0, 0, 0 }, /* ditto */
{ "magenta", CLR_MAGENTA },
{ "cyan", CLR_CYAN },
{ "gray", CLR_GRAY },
- { "grey", CLR_GRAY },
{ "orange", CLR_ORANGE },
{ "light green", CLR_BRIGHT_GREEN },
{ "yellow", CLR_YELLOW },
{ "light blue", CLR_BRIGHT_BLUE },
{ "light magenta", CLR_BRIGHT_MAGENTA },
{ "light cyan", CLR_BRIGHT_CYAN },
- { "white", CLR_WHITE }
+ { "white", CLR_WHITE },
+ { "no color", NO_COLOR },
+ { NULL, CLR_BLACK }, /* everything after this is an alias */
+ { "transparent", NO_COLOR },
+ { "purple", CLR_MAGENTA },
+ { "light purple", CLR_BRIGHT_MAGENTA },
+ { "bright purple", CLR_BRIGHT_MAGENTA },
+ { "grey", CLR_GRAY },
+ { "bright red", CLR_ORANGE },
+ { "bright green", CLR_BRIGHT_GREEN },
+ { "bright blue", CLR_BRIGHT_BLUE },
+ { "bright magenta", CLR_BRIGHT_MAGENTA },
+ { "bright cyan", CLR_BRIGHT_CYAN }
};
static const struct {
{ "dim", ATR_DIM },
{ "underline", ATR_ULINE },
{ "blink", ATR_BLINK },
- { "inverse", ATR_INVERSE }
+ { "inverse", ATR_INVERSE },
+ { NULL, ATR_NONE }, /* everything after this is an alias */
+ { "normal", ATR_NONE },
+ { "uline", ATR_ULINE }
};
const char *
int i;
for (i = 0; i < SIZE(colornames); i++)
- if (colornames[i].color == clr)
+ if (colornames[i].name && colornames[i].color == clr)
return colornames[i].name;
return (char *) 0;
}
-const char *
+int
+match_str2clr(str)
+char *str;
+{
+ int i, c = CLR_MAX;
+
+ /* allow "lightblue", "light blue", and "light-blue" to match "light blue"
+ (also junk like "_l i-gh_t---b l u e" but we won't worry about that);
+ also copes with trailing space; mungspaces removed any leading space */
+ for (i = 0; i < SIZE(colornames); i++)
+ if (colornames[i].name
+ && fuzzymatch(str, colornames[i].name, " -_", TRUE)) {
+ c = colornames[i].color;
+ break;
+ }
+ if (i == SIZE(colornames) && (*str >= '0' && *str <= '9'))
+ c = atoi(str);
+
+ if (c == CLR_MAX)
+ config_error_add("Unknown color '%s'", str);
+
+ return c;
+}
+
+STATIC_OVL const char *
attr2attrname(attr)
int attr;
{
}
int
-query_color()
+match_str2attr(str, complain)
+const char *str;
+boolean complain;
+{
+ int i, a = -1;
+
+ for (i = 0; i < SIZE(attrnames); i++)
+ if (attrnames[i].name
+ && fuzzymatch(str, attrnames[i].name, " -_", TRUE)) {
+ a = attrnames[i].attr;
+ break;
+ }
+
+ if (a == -1 && complain)
+ config_error_add("Unknown text attribute '%s'", str);
+
+ return a;
+}
+
+int
+query_color(prompt)
+const char *prompt;
{
winid tmpwin;
anything any;
start_menu(tmpwin);
any = zeroany;
for (i = 0; i < SIZE(colornames); i++) {
- if (!strcmp(colornames[i].name, "grey"))
- continue;
+ if (!colornames[i].name)
+ break;
any.a_int = i + 1;
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, colornames[i].name,
MENU_UNSELECTED);
}
- end_menu(tmpwin, "Pick a color");
+ end_menu(tmpwin, (prompt && *prompt) ? prompt : "Pick a color");
pick_cnt = select_menu(tmpwin, PICK_ONE, &picks);
destroy_nhwindow(tmpwin);
if (pick_cnt > 0) {
start_menu(tmpwin);
any = zeroany;
for (i = 0; i < SIZE(attrnames); i++) {
+ if (!attrnames[i].name)
+ break;
any.a_int = i + 1;
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, attrnames[i].attr,
attrnames[i].name, MENU_UNSELECTED);
}
- end_menu(tmpwin, prompt ? prompt : "Pick an attribute");
+ end_menu(tmpwin, (prompt && *prompt) ? prompt : "Pick an attribute");
pick_cnt = select_menu(tmpwin, PICK_ONE, &picks);
destroy_nhwindow(tmpwin);
if (pick_cnt > 0) {
static const struct {
const char *name;
- const xchar msgtyp;
+ xchar msgtyp;
const char *descr;
} msgtype_names[] = {
{ "show", MSGTYP_NORMAL, "Show message normally" },
{ "norep", MSGTYP_NOREP, "Do not repeat the message" }
};
-const char *
+STATIC_OVL const char *
msgtype2name(typ)
int typ;
{
return -1;
}
-boolean
+STATIC_OVL boolean
msgtype_add(typ, pattern)
int typ;
char *pattern;
{
- struct plinemsg_type *tmp
- = (struct plinemsg_type *) alloc(sizeof (struct plinemsg_type));
+ struct plinemsg_type
+ *tmp = (struct plinemsg_type *) alloc(sizeof (struct plinemsg_type));
- if (!tmp)
- return FALSE;
tmp->msgtype = typ;
tmp->regex = regex_init();
if (!regex_compile(pattern, tmp->regex)) {
static const char *re_error = "MSGTYPE regex error";
- if (!iflags.window_inited)
- raw_printf("\n%s: %s\n", re_error, regex_error_desc(tmp->regex));
- else
- pline("%s: %s", re_error, regex_error_desc(tmp->regex));
- wait_synch();
+ config_error_add("%s: %s", re_error, regex_error_desc(tmp->regex));
regex_free(tmp->regex);
free((genericptr_t) tmp);
return FALSE;
plinemsg_types = (struct plinemsg_type *) 0;
}
-void
+STATIC_OVL void
free_one_msgtype(idx)
int idx; /* 0 .. */
{
}
int
-msgtype_type(msg)
+msgtype_type(msg, norepeat)
const char *msg;
+boolean norepeat; /* called from Norep(via pline) */
{
struct plinemsg_type *tmp = plinemsg_types;
while (tmp) {
+ /* we don't exclude entries with negative msgtype values
+ because then the msg might end up matching a later pattern */
if (regex_match(msg, tmp->regex))
return tmp->msgtype;
tmp = tmp->next;
}
- return MSGTYP_NORMAL;
+ return norepeat ? MSGTYP_NOREP : MSGTYP_NORMAL;
}
-int
-msgtype_count()
+/* negate one or more types of messages so that their type handling will
+ be disabled or re-enabled; MSGTYPE_NORMAL (value 0) is not affected */
+void
+hide_unhide_msgtypes(hide, hide_mask)
+boolean hide;
+int hide_mask;
+{
+ struct plinemsg_type *tmp;
+ int mt;
+
+ /* negative msgtype value won't be recognized by pline, so does nothing */
+ for (tmp = plinemsg_types; tmp; tmp = tmp->next) {
+ mt = tmp->msgtype;
+ if (!hide)
+ mt = -mt; /* unhide: negate negative, yielding positive */
+ if (mt > 0 && ((1 << mt) & hide_mask))
+ tmp->msgtype = -tmp->msgtype;
+ }
+}
+
+STATIC_OVL int
+msgtype_count(VOID_ARGS)
{
int c = 0;
struct plinemsg_type *tmp = plinemsg_types;
}
if (typ != -1)
return msgtype_add(typ, pattern);
+ else
+ config_error_add("Unknown message type '%s'", msgtype);
+ } else {
+ config_error_add("Malformed MSGTYPE");
}
return FALSE;
}
+STATIC_OVL boolean
+test_regex_pattern(str, errmsg)
+const char *str;
+const char *errmsg;
+{
+ static const char re_error[] = "Regex error";
+ struct nhregex *match;
+ boolean retval = TRUE;
+
+ if (!str)
+ return FALSE;
+
+ match = regex_init();
+ if (!match) {
+ config_error_add("NHregex error");
+ return FALSE;
+ }
+
+ if (!regex_compile(str, match)) {
+ config_error_add("%s: %s", errmsg ? errmsg : re_error,
+ regex_error_desc(match));
+ retval = FALSE;
+ }
+ regex_free(match);
+ return retval;
+}
+
boolean
add_menu_coloring_parsed(str, c, a)
char *str;
tmp = (struct menucoloring *) alloc(sizeof (struct menucoloring));
tmp->match = regex_init();
if (!regex_compile(str, tmp->match)) {
- if (!iflags.window_inited)
- raw_printf("\n%s: %s\n", re_error, regex_error_desc(tmp->match));
- else
- pline("%s: %s", re_error, regex_error_desc(tmp->match));
- wait_synch();
+ config_error_add("%s: %s", re_error, regex_error_desc(tmp->match));
regex_free(tmp->match);
free(tmp);
return FALSE;
/* parse '"regex_string"=color&attr' and add it to menucoloring */
boolean
-add_menu_coloring(str)
-char *str;
+add_menu_coloring(tmpstr)
+char *tmpstr;
{
- int i, c = NO_COLOR, a = ATR_NONE;
+ int c = NO_COLOR, a = ATR_NONE;
char *tmps, *cs, *amp;
+ char str[BUFSZ];
- if (!str || (cs = index(str, '=')) == 0)
+ Sprintf(str, "%s", tmpstr);
+
+ if (!tmpstr || (cs = index(str, '=')) == 0) {
+ config_error_add("Malformed MENUCOLOR");
return FALSE;
+ }
tmps = cs + 1; /* advance past '=' */
mungspaces(tmps);
if ((amp = index(tmps, '&')) != 0)
*amp = '\0';
- /* allow "lightblue", "light blue", and "light-blue" to match "light blue"
- (also junk like "_l i-gh_t---b l u e" but we won't worry about that);
- also copes with trailing space; mungspaces removed any leading space */
- for (i = 0; i < SIZE(colornames); i++)
- if (fuzzymatch(tmps, colornames[i].name, " -_", TRUE)) {
- c = colornames[i].color;
- break;
- }
- if (i == SIZE(colornames) && (*tmps >= '0' && *tmps <= '9'))
- c = atoi(tmps);
-
- if (c > 15)
+ c = match_str2clr(tmps);
+ if (c >= CLR_MAX)
return FALSE;
if (amp) {
tmps = amp + 1; /* advance past '&' */
- /* unlike colors, none of he attribute names has any embedded spaces,
- but use of fuzzymatch() allows us ignore the presence of leading
- and/or trailing (and also embedded) spaces in the user's string;
- dash and underscore skipping could be omitted but does no harm */
- for (i = 0; i < SIZE(attrnames); i++)
- if (fuzzymatch(tmps, attrnames[i].name, " -_", TRUE)) {
- a = attrnames[i].attr;
- break;
- }
- if (i == SIZE(attrnames) && (*tmps >= '0' && *tmps <= '9'))
- a = atoi(tmps);
+ a = match_str2attr(tmps, TRUE);
+ if (a == -1)
+ return FALSE;
}
/* the regexp portion here has not been condensed by mungspaces() */
boolean
get_menu_coloring(str, color, attr)
-char *str;
+const char *str;
int *color, *attr;
{
struct menucoloring *tmpmc;
}
}
-void
+STATIC_OVL void
free_one_menu_coloring(idx)
int idx; /* 0 .. */
{
}
}
-int
-count_menucolors()
+STATIC_OVL int
+count_menucolors(VOID_ARGS)
{
int count = 0;
struct menucoloring *tmp = menu_colorings;
return count;
}
-void
+STATIC_OVL boolean
+parse_role_opts(negated, fullname, opts, opp)
+boolean negated;
+const char *fullname;
+char *opts;
+char **opp;
+{
+ char *op = *opp;
+
+ if (negated) {
+ bad_negation(fullname, FALSE);
+ } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
+ boolean val_negated = FALSE;
+
+ while ((*op == '!') || !strncmpi(op, "no", 2)) {
+ if (*op == '!')
+ op++;
+ else
+ op += 2;
+ val_negated = !val_negated;
+ }
+ if (val_negated) {
+ if (!setrolefilter(op)) {
+ config_error_add("Unknown negated parameter '%s'", op);
+ return FALSE;
+ }
+ } else {
+ if (duplicate_opt_detection(opts, 1))
+ complain_about_duplicate(opts, 1);
+ *opp = op;
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+/* Check if character c is illegal as a menu command key */
+boolean
+illegal_menu_cmd_key(c)
+char c;
+{
+ if (c == 0 || c == '\r' || c == '\n' || c == '\033'
+ || c == ' ' || digit(c) || (letter(c) && c != '@')) {
+ config_error_add("Reserved menu command key '%s'", visctrl(c));
+ return TRUE;
+ } else { /* reject default object class symbols */
+ int j;
+ for (j = 1; j < MAXOCLASSES; j++)
+ if (c == def_oc_syms[j].sym) {
+ config_error_add("Menu command key '%s' is an object class",
+ visctrl(c));
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+boolean
parseoptions(opts, tinitial, tfrom_file)
register char *opts;
boolean tinitial, tfrom_file;
{
- register char *op;
+ char *op;
unsigned num;
- boolean negated, val_negated, duplicate;
+ boolean negated, duplicate;
int i;
const char *fullname;
+ boolean retval = TRUE;
initial = tinitial;
from_file = tfrom_file;
if ((op = index(opts, ',')) != 0) {
*op++ = 0;
- parseoptions(op, initial, from_file);
+ if (!parseoptions(op, initial, from_file))
+ retval = FALSE;
}
if (strlen(opts) > BUFSZ / 2) {
- badoption("option too long");
- return;
+ config_error_add("Option too long, max length is %i characters",
+ (BUFSZ / 2));
+ return FALSE;
}
/* strip leading and trailing white space */
while (--op >= opts && isspace((uchar) *op))
*op = '\0';
- if (!*opts)
- return;
+ if (!*opts) {
+ config_error_add("Empty statement");
+ return FALSE;
+ }
negated = FALSE;
while ((*opts == '!') || !strncmpi(opts, "no", 2)) {
if (*opts == '!')
if (match_optname(opts, "female", 3, FALSE)) {
if (duplicate_opt_detection(opts, 0))
complain_about_duplicate(opts, 0);
- if (!initial && flags.female == negated)
- pline("That is not anatomically possible.");
- else
+ if (!initial && flags.female == negated) {
+ config_error_add("That is not anatomically possible.");
+ return FALSE;
+ } else
flags.initgend = flags.female = !negated;
- return;
+ return retval;
}
if (match_optname(opts, "male", 4, FALSE)) {
if (duplicate_opt_detection(opts, 0))
complain_about_duplicate(opts, 0);
- if (!initial && flags.female != negated)
- pline("That is not anatomically possible.");
- else
+ if (!initial && flags.female != negated) {
+ config_error_add("That is not anatomically possible.");
+ return FALSE;
+ } else
flags.initgend = flags.female = negated;
- return;
+ return retval;
}
#if defined(MICRO) && !defined(AMIGA)
/* included for compatibility with old NetHack.cnf files */
if (match_optname(opts, "IBM_", 4, FALSE)) {
iflags.BIOS = !negated;
- return;
+ return retval;
}
#endif /* MICRO */
/* align:string */
fullname = "align";
if (match_optname(opts, fullname, sizeof("align") - 1, TRUE)) {
- if (negated) {
- bad_negation(fullname, FALSE);
- } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
- val_negated = FALSE;
- while ((*op == '!') || !strncmpi(op, "no", 2)) {
- if (*op == '!')
- op++;
- else
- op += 2;
- val_negated = !val_negated;
- }
- if (val_negated) {
- if (!setrolefilter(op))
- badoption(opts);
- } else {
- if (duplicate_opt_detection(opts, 1))
- complain_about_duplicate(opts, 1);
- if ((flags.initalign = str2align(op)) == ROLE_NONE)
- badoption(opts);
+ if (parse_role_opts(negated, fullname, opts, &op)) {
+ if ((flags.initalign = str2align(op)) == ROLE_NONE) {
+ config_error_add("Unknown %s '%s'", fullname, op);
+ return FALSE;
}
- }
- return;
+ } else
+ return FALSE;
+ return retval;
}
/* role:string or character:string */
fullname = "role";
if (match_optname(opts, fullname, 4, TRUE)
|| match_optname(opts, (fullname = "character"), 4, TRUE)) {
- if (negated) {
- bad_negation(fullname, FALSE);
- } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
- val_negated = FALSE;
- while ((*op == '!') || !strncmpi(op, "no", 2)) {
- if (*op == '!')
- op++;
- else
- op += 2;
- val_negated = !val_negated;
- }
- if (val_negated) {
- if (!setrolefilter(op))
- badoption(opts);
- } else {
- if (duplicate_opt_detection(opts, 1))
- complain_about_duplicate(opts, 1);
- if ((flags.initrole = str2role(op)) == ROLE_NONE)
- badoption(opts);
- else /* Backwards compatibility */
- nmcpy(pl_character, op, PL_NSIZ);
- }
- }
- return;
+ if (parse_role_opts(negated, fullname, opts, &op)) {
+ if ((flags.initrole = str2role(op)) == ROLE_NONE) {
+ config_error_add("Unknown %s '%s'", fullname, op);
+ return FALSE;
+ } else /* Backwards compatibility */
+ nmcpy(pl_character, op, PL_NSIZ);
+ } else
+ return FALSE;
+ return retval;
}
/* race:string */
fullname = "race";
if (match_optname(opts, fullname, 4, TRUE)) {
- if (negated) {
- bad_negation(fullname, FALSE);
- } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
- val_negated = FALSE;
- while ((*op == '!') || !strncmpi(op, "no", 2)) {
- if (*op == '!')
- op++;
- else
- op += 2;
- val_negated = !val_negated;
- }
- if (val_negated) {
- if (!setrolefilter(op))
- badoption(opts);
- } else {
- if (duplicate_opt_detection(opts, 1))
- complain_about_duplicate(opts, 1);
- if ((flags.initrace = str2race(op)) == ROLE_NONE)
- badoption(opts);
- else /* Backwards compatibility */
- pl_race = *op;
- }
- }
- return;
+ if (parse_role_opts(negated, fullname, opts, &op)) {
+ if ((flags.initrace = str2race(op)) == ROLE_NONE) {
+ config_error_add("Unknown %s '%s'", fullname, op);
+ return FALSE;
+ } else /* Backwards compatibility */
+ pl_race = *op;
+ } else
+ return FALSE;
+ return retval;
}
/* gender:string */
fullname = "gender";
if (match_optname(opts, fullname, 4, TRUE)) {
- if (negated) {
- bad_negation(fullname, FALSE);
- } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
- val_negated = FALSE;
- while ((*op == '!') || !strncmpi(op, "no", 2)) {
- if (*op == '!')
- op++;
- else
- op += 2;
- val_negated = !val_negated;
- }
- if (val_negated) {
- if (!setrolefilter(op))
- badoption(opts);
- } else {
- if (duplicate_opt_detection(opts, 1))
- complain_about_duplicate(opts, 1);
- if ((flags.initgend = str2gend(op)) == ROLE_NONE)
- badoption(opts);
- else
- flags.female = flags.initgend;
- }
- }
- return;
+ if (parse_role_opts(negated, fullname, opts, &op)) {
+ if ((flags.initgend = str2gend(op)) == ROLE_NONE) {
+ config_error_add("Unknown %s '%s'", fullname, op);
+ return FALSE;
+ } else
+ flags.female = flags.initgend;
+ } else
+ return FALSE;
+ return retval;
}
/* We always check for duplicates on the remaining compound options,
although individual option processing can choose to complain or not */
- duplicate =
- duplicate_opt_detection(opts, 1); /* 1 means check compounds */
+ duplicate = duplicate_opt_detection(opts, 1); /* 1: check compounds */
fullname = "pettype";
if (match_optname(opts, fullname, 3, TRUE)) {
if (duplicate)
complain_about_duplicate(opts, 1);
if ((op = string_for_env_opt(fullname, opts, negated)) != 0) {
- if (negated)
+ if (negated) {
bad_negation(fullname, TRUE);
- else
+ return FALSE;
+ } else
switch (lowc(*op)) {
case 'd': /* dog */
preferred_pet = 'd';
preferred_pet = '\0';
break;
default:
- pline("Unrecognized pet type '%s'.", op);
+/*JP
+ config_error_add("Unrecognized pet type '%s'.", op);
+*/
+ pline("'%s'\82Í\83y\83b\83g\82Ì\8eí\97Þ\82Æ\82µ\82Ä\8eó\82¯\95t\82¯\82ç\82ê\82Ü\82¹\82ñ\81D", op);
+ return FALSE;
break;
}
} else if (negated)
preferred_pet = 'n';
- return;
+ return retval;
}
fullname = "catname";
if (match_optname(opts, fullname, 3, TRUE)) {
if (duplicate)
complain_about_duplicate(opts, 1);
- if (negated)
+ if (negated) {
bad_negation(fullname, FALSE);
- else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0)
+ return FALSE;
+ } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
nmcpy(catname, op, PL_PSIZ);
+ } else
+ return FALSE;
sanitize_name(catname);
- return;
+ return retval;
}
fullname = "dogname";
if (match_optname(opts, fullname, 3, TRUE)) {
if (duplicate)
complain_about_duplicate(opts, 1);
- if (negated)
+ if (negated) {
bad_negation(fullname, FALSE);
- else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0)
+ return FALSE;
+ } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
nmcpy(dogname, op, PL_PSIZ);
+ } else
+ return FALSE;
sanitize_name(dogname);
- return;
+ return retval;
}
fullname = "horsename";
if (match_optname(opts, fullname, 5, TRUE)) {
if (duplicate)
complain_about_duplicate(opts, 1);
- if (negated)
+ if (negated) {
bad_negation(fullname, FALSE);
- else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0)
+ return FALSE;
+ } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
nmcpy(horsename, op, PL_PSIZ);
+ } else
+ return FALSE;
sanitize_name(horsename);
- return;
+ return retval;
}
fullname = "number_pad";
iflags.num_pad_mode = 0;
}
} else if (negated) {
- bad_negation("number_pad", TRUE);
- return;
+ bad_negation(fullname, TRUE);
+ return FALSE;
} else {
int mode = atoi(op);
if (mode < -1 || mode > 4 || (mode == 0 && *op != '0')) {
- badoption(opts);
- return;
+ config_error_add("Illegal %s parameter '%s'", fullname, op);
+ return FALSE;
} else if (mode <= 0) {
iflags.num_pad = FALSE;
/* German keyboard; y and z keys swapped */
}
reset_commands(FALSE);
number_pad(iflags.num_pad ? 1 : 0);
- return;
+ return retval;
}
fullname = "roguesymset";
complain_about_duplicate(opts, 1);
if (negated) {
bad_negation(fullname, FALSE);
+ return FALSE;
} else if ((op = string_for_opt(opts, FALSE)) != 0) {
symset[ROGUESET].name = dupstr(op);
if (!read_sym_file(ROGUESET)) {
clear_symsetentry(ROGUESET, TRUE);
- raw_printf("Unable to load symbol set \"%s\" from \"%s\".",
+ config_error_add("Unable to load symbol set \"%s\" from \"%s\"",
op, SYMBOLS);
- wait_synch();
+ return FALSE;
} else {
if (!initial && Is_rogue_level(&u.uz))
assign_graphics(ROGUESET);
need_redraw = TRUE;
}
- }
- return;
+ } else
+ return FALSE;
+ return retval;
}
fullname = "symset";
complain_about_duplicate(opts, 1);
if (negated) {
bad_negation(fullname, FALSE);
+ return FALSE;
} else if ((op = string_for_opt(opts, FALSE)) != 0) {
symset[PRIMARY].name = dupstr(op);
if (!read_sym_file(PRIMARY)) {
clear_symsetentry(PRIMARY, TRUE);
- raw_printf("Unable to load symbol set \"%s\" from \"%s\".",
- op, SYMBOLS);
- wait_synch();
+ config_error_add(
+ "Unable to load symbol set \"%s\" from \"%s\"",
+ op, SYMBOLS);
+ return FALSE;
} else {
- switch_symbols(TRUE);
+ switch_symbols(symset[PRIMARY].name != (char *) 0);
need_redraw = TRUE;
}
- }
- return;
+ } else
+ return FALSE;
+ return retval;
}
fullname = "runmode";
flags.runmode = RUN_STEP;
else if (!strncmpi(op, "crawl", strlen(op)))
flags.runmode = RUN_CRAWL;
- else
- badoption(opts);
- }
- return;
+ else {
+ config_error_add("Unknown %s parameter '%s'", fullname, op);
+ return FALSE;
+ }
+ } else
+ return FALSE;
+ return retval;
}
/* menucolor:"regex_string"=color */
fullname = "menucolor";
if (match_optname(opts, fullname, 9, TRUE)) {
- if (negated)
+ if (negated) {
bad_negation(fullname, FALSE);
- else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0)
+ return FALSE;
+ } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
if (!add_menu_coloring(op))
- badoption(opts);
- return;
+ return FALSE;
+ } else
+ return FALSE;
+ return retval;
}
fullname = "msghistory";
op = string_for_env_opt(fullname, opts, negated);
if ((negated && !op) || (!negated && op)) {
iflags.msg_history = negated ? 0 : atoi(op);
- } else if (negated)
+ } else if (negated) {
bad_negation(fullname, TRUE);
- return;
+ return FALSE;
+ }
+ return retval;
}
fullname = "msg_window";
} else {
if (negated) {
bad_negation(fullname, TRUE);
- return;
+ return FALSE;
}
- tmp = tolower(*op);
+ tmp = lowc(*op);
}
switch (tmp) {
case 's': /* single message history cycle (default if negated) */
case 'r': /* full page (reversed) */
iflags.prevmsg_window = 'r';
break;
- default:
- badoption(opts);
+ default: {
+ config_error_add("Unknown %s parameter '%s'", fullname, op);
+ return FALSE;
+ }
}
#endif
- return;
+ return retval;
}
/* WINCAP
else if (!strncmpi(fontopts, "_size_status", 11))
opttype = STATUS_OPTION;
else {
- badoption(opts);
- return;
+ config_error_add("Unknown %s parameter '%s'", fullname, opts);
+ return FALSE;
}
if (duplicate)
complain_about_duplicate(opts, 1);
break;
}
}
- return;
+ return retval;
} else {
- badoption(opts);
+ config_error_add("Unknown %s parameter '%s'", fullname, opts);
+ return FALSE;
}
if (opttype > 0 && (op = string_for_opt(opts, FALSE)) != 0) {
wc_set_font_name(opttype, op);
#ifdef MAC
set_font_name(opttype, op);
#endif
- return;
- } else if (negated)
+ return retval;
+ } else if (negated) {
bad_negation(fullname, TRUE);
- return;
+ return FALSE;
+ }
+ return retval;
}
+
#ifdef CHANGE_COLOR
if (match_optname(opts, "palette", 3, TRUE)
#ifdef MAC
|| match_optname(opts, "hicolor", 3, TRUE)
#endif
- ) {
+ ) {
int color_number, color_incr;
#ifndef WIN32
if (match_optname(opts, "hicolor", 3, TRUE)) {
if (negated) {
bad_negation("hicolor", FALSE);
- return;
+ return FALSE;
}
color_number = CLR_MAX + 4; /* HARDCODED inverse number */
color_incr = -1;
- } else {
+ } else
#endif
+ {
if (negated) {
bad_negation("palette", FALSE);
- return;
+ return FALSE;
}
color_number = 0;
color_incr = 1;
-#ifdef MAC
}
-#endif
#ifdef WIN32
op = string_for_opt(opts, TRUE);
- if (!alternative_palette(op))
- badoption(opts);
+ if (!alternative_palette(op)) {
+ config_error_add("Error in palette parameter '%s'", op);
+ return FALSE;
+ }
#else
if ((op = string_for_opt(opts, FALSE)) != (char *) 0) {
char *pt = op;
#else
rgb <<= 8;
#endif
- tmp = *(pt++);
- if (isalpha(tmp)) {
+ tmp = *pt++;
+ if (isalpha((uchar) tmp)) {
tmp = (tmp + 9) & 0xf; /* Assumes ASCII... */
} else {
tmp &= 0xf; /* Digits in ASCII too... */
rgb += tmp;
}
}
- if (*pt == '/') {
+ if (*pt == '/')
pt++;
- }
change_color(color_number, rgb, reverse);
color_number += color_incr;
}
if (!initial) {
need_redraw = TRUE;
}
- return;
+ return retval;
}
#endif /* CHANGE_COLOR */
if (negated) {
if (op) {
bad_negation("fruit", TRUE);
- return;
+ return FALSE;
}
op = &empty_str;
goto goodfruit;
}
if (!op)
- return;
+ return FALSE;
if (!initial) {
struct fruit *f;
-
- num = 0;
- for (f = ffruit; f; f = f->nextf) {
- if (!strcmp(op, f->fname))
- break;
- num++;
- }
- if (!flags.made_fruit) {
- for (forig = ffruit; forig; forig = forig->nextf) {
- if (!strcmp(pl_fruit, forig->fname)) {
- break;
- }
+ int fnum = 0;
+
+ /* count number of named fruits; if 'op' is found among them,
+ then the count doesn't matter because we won't be adding it */
+ f = fruit_from_name(op, FALSE, &fnum);
+ if (!f) {
+ if (!flags.made_fruit)
+ forig = fruit_from_name(pl_fruit, FALSE, (int *) 0);
+
+ if (!forig && fnum >= 100) {
+#if 0 /*JP*/
+ config_error_add(
+ "Doing that so many times isn't very fruitful.");
+#else
+ config_error_add(
+ "\82»\82ñ\82È\82É\89½\89ñ\82à\82â\82Á\82Ä\82à\82Ù\82Æ\82ñ\82Ç\88Ó\96¡\82Í\82È\82¢\81D");
+#endif
+ return retval;
}
}
- if (!forig && num >= 100) {
- pline("Doing that so many times isn't very fruitful.");
- return;
- }
}
goodfruit:
nmcpy(pl_fruit, op, PL_FSIZ);
sanitize_name(pl_fruit);
- /* OBJ_NAME(objects[SLIME_MOLD]) won't work after initialization */
+ /* OBJ_NAME(objects[SLIME_MOLD]) won't work for this after
+ initialization; it gets changed to generic "fruit" */
if (!*pl_fruit)
nmcpy(pl_fruit, "slime mold", PL_FSIZ);
if (!initial) {
+ /* if 'forig' is nonNull, we replace it rather than add
+ a new fruit; it can only be nonNull if no fruits have
+ been created since the previous name was put in place */
(void) fruitadd(pl_fruit, forig);
pline("Fruit is now \"%s\".", pl_fruit);
}
* no fruit option at all. Also, we don't want people
* setting multiple fruits in their options.)
*/
- return;
+ return retval;
+ }
+
+ fullname = "whatis_coord";
+ if (match_optname(opts, fullname, 8, TRUE)) {
+ if (duplicate)
+ complain_about_duplicate(opts, 1);
+ if (negated) {
+ iflags.getpos_coords = GPCOORDS_NONE;
+ return retval;
+ } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
+ static char gpcoords[] = { GPCOORDS_NONE, GPCOORDS_COMPASS,
+ GPCOORDS_COMFULL, GPCOORDS_MAP,
+ GPCOORDS_SCREEN, '\0' };
+ char c = lowc(*op);
+
+ if (c && index(gpcoords, c))
+ iflags.getpos_coords = c;
+ else {
+ config_error_add("Unknown %s parameter '%s'", fullname, op);
+ return FALSE;
+ }
+ } else
+ return FALSE;
+ return retval;
+ }
+
+ fullname = "whatis_filter";
+ if (match_optname(opts, fullname, 8, TRUE)) {
+ if (duplicate)
+ complain_about_duplicate(opts, 1);
+ if (negated) {
+ iflags.getloc_filter = GFILTER_NONE;
+ return retval;
+ } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
+ char c = lowc(*op);
+
+ switch (c) {
+ case 'n':
+ iflags.getloc_filter = GFILTER_NONE;
+ break;
+ case 'v':
+ iflags.getloc_filter = GFILTER_VIEW;
+ break;
+ case 'a':
+ iflags.getloc_filter = GFILTER_AREA;
+ break;
+ default: {
+ config_error_add("Unknown %s parameter '%s'", fullname, op);
+ return FALSE;
+ }
+ }
+ } else
+ return FALSE;
+ return retval;
}
fullname = "warnings";
if (match_optname(opts, fullname, 5, TRUE)) {
if (duplicate)
complain_about_duplicate(opts, 1);
- if (negated)
+ if (negated) {
bad_negation(fullname, FALSE);
- else
- warning_opts(opts, fullname);
- return;
+ return FALSE;
+ }
+ return warning_opts(opts, fullname);
}
-#ifdef BACKWARD_COMPAT
/* boulder:symbol */
fullname = "boulder";
if (match_optname(opts, fullname, 7, TRUE)) {
+#ifdef BACKWARD_COMPAT
int clash = 0;
+
if (duplicate)
complain_about_duplicate(opts, 1);
if (negated) {
bad_negation(fullname, FALSE);
- return;
+ return FALSE;
}
/* if (!(opts = string_for_env_opt(fullname, opts, FALSE)))
*/
if (!(opts = string_for_opt(opts, FALSE)))
- return;
+ return FALSE;
escapes(opts, opts);
if (def_char_to_monclass(opts[0]) != MAXMCLASSES)
clash = 1;
if (clash) {
/* symbol chosen matches a used monster or warning
symbol which is not good - reject it*/
- pline(
+ config_error_add(
"Badoption - boulder symbol '%c' conflicts with a %s symbol.",
- opts[0], (clash == 1) ? "monster" : "warning");
+ opts[0], (clash == 1) ? "monster" : "warning");
} else {
/*
* Override the default boulder symbol.
*/
iflags.bouldersym = (uchar) opts[0];
}
- if (!initial)
+ /* for 'initial', update_bouldersym() is done in initoptions_finish(),
+ after all symset options have been processed */
+ if (!initial) {
+ update_bouldersym();
need_redraw = TRUE;
- return;
- }
+ }
+ return retval;
+#else
+ config_error_add("'%s' no longer supported; use S_boulder:c instead",
+ fullname);
+ return FALSE;
#endif
+ }
/* name:string */
fullname = "name";
if (match_optname(opts, fullname, 4, TRUE)) {
if (duplicate)
complain_about_duplicate(opts, 1);
- if (negated)
+ if (negated) {
bad_negation(fullname, FALSE);
- else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0)
+ return FALSE;
+ } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
nmcpy(plname, op, PL_NSIZ);
- return;
+ } else
+ return FALSE;
+ return retval;
}
/* altkeyhandler:string */
complain_about_duplicate(opts, 1);
if (negated) {
bad_negation(fullname, FALSE);
+ return FALSE;
} else if ((op = string_for_opt(opts, negated)) != 0) {
#ifdef WIN32
(void) strncpy(iflags.altkeyhandler, op, MAX_ALTKEYHANDLER - 5);
load_keyboard_handler();
#endif
- }
- return;
+ } else
+ return FALSE;
+ return retval;
}
/* WINCAP
iflags.wc_align_status = ALIGN_RIGHT;
else if (!strncmpi(op, "bottom", sizeof("bottom") - 1))
iflags.wc_align_status = ALIGN_BOTTOM;
- else
- badoption(opts);
- } else if (negated)
+ else {
+ config_error_add("Unknown %s parameter '%s'", fullname, op);
+ return FALSE;
+ }
+ } else if (negated) {
bad_negation(fullname, TRUE);
- return;
+ return FALSE;
+ }
+ return retval;
}
+
/* WINCAP
* align_message:[left|top|right|bottom] */
fullname = "align_message";
iflags.wc_align_message = ALIGN_RIGHT;
else if (!strncmpi(op, "bottom", sizeof("bottom") - 1))
iflags.wc_align_message = ALIGN_BOTTOM;
- else
- badoption(opts);
- } else if (negated)
+ else {
+ config_error_add("Unknown %s parameter '%s'", fullname, op);
+ return FALSE;
+ }
+ } else if (negated) {
bad_negation(fullname, TRUE);
- return;
+ return FALSE;
+ }
+ return retval;
}
- /* the order to list the pack */
+
+ /* the order to list inventory */
fullname = "packorder";
if (match_optname(opts, fullname, 4, TRUE)) {
if (duplicate)
complain_about_duplicate(opts, 1);
if (negated) {
bad_negation(fullname, FALSE);
- return;
+ return FALSE;
} else if (!(op = string_for_opt(opts, FALSE)))
- return;
+ return FALSE;
if (!change_inv_order(op))
- badoption(opts);
- return;
+ return FALSE;
+ return retval;
}
/* user can change required response for some prompts (quit, die, hit),
} else if ((op = string_for_opt(opts, TRUE)) != 0) {
char *pp, buf[BUFSZ];
- op = mungspaces(strcpy(buf, op));
+ strncpy(buf, op, sizeof buf - 1);
+ buf[sizeof buf - 1] = '\0';
+ op = mungspaces(buf);
for (;;) {
/* We're looking to parse
"paranoid_confirm:whichone wheretwo whothree"
if (i == SIZE(paranoia)) {
/* didn't match anything, so arg is bad;
any flags already set will stay set */
- badoption(opts);
- break;
+ config_error_add("Unknown %s parameter '%s'",
+ fullname, op);
+ return FALSE;
}
/* move on to next token */
if (pp)
op = pp + 1;
else
break; /* no next token */
- } /* for(;;) */
- }
- return;
+ } /* for(;;) */
+ } else
+ return FALSE;
+ return retval;
}
/* accept deprecated boolean; superseded by paranoid_confirm:pray */
flags.paranoia_bits &= ~PARANOID_PRAY;
else
flags.paranoia_bits |= PARANOID_PRAY;
- return;
+ return retval;
}
/* maximum burden picked up before prompt (Warren Cheung) */
complain_about_duplicate(opts, 1);
if (negated) {
bad_negation(fullname, FALSE);
- return;
+ return FALSE;
} else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
- switch (tolower(*op)) {
- /* Unencumbered */
- case 'u':
+ switch (lowc(*op)) {
+ case 'u': /* Unencumbered */
flags.pickup_burden = UNENCUMBERED;
break;
- /* Burdened (slight encumbrance) */
- case 'b':
+ case 'b': /* Burdened (slight encumbrance) */
flags.pickup_burden = SLT_ENCUMBER;
break;
- /* streSsed (moderate encumbrance) */
- case 's':
+ case 's': /* streSsed (moderate encumbrance) */
flags.pickup_burden = MOD_ENCUMBER;
break;
- /* straiNed (heavy encumbrance) */
- case 'n':
+ case 'n': /* straiNed (heavy encumbrance) */
flags.pickup_burden = HVY_ENCUMBER;
break;
- /* OverTaxed (extreme encumbrance) */
- case 'o':
+ case 'o': /* OverTaxed (extreme encumbrance) */
case 't':
flags.pickup_burden = EXT_ENCUMBER;
break;
- /* overLoaded */
- case 'l':
+ case 'l': /* overLoaded */
flags.pickup_burden = OVERLOADED;
break;
default:
- badoption(opts);
+ config_error_add("Unknown %s parameter '%s'", fullname, op);
+ return FALSE;
}
- }
- return;
+ } else
+ return FALSE;
+ return retval;
}
/* types of objects to pick up automatically */
- if (match_optname(opts, "pickup_types", 8, TRUE)) {
+ fullname = "pickup_types";
+ if (match_optname(opts, fullname, 8, TRUE)) {
char ocl[MAXOCLASSES + 1], tbuf[MAXOCLASSES + 1], qbuf[QBUFSZ],
- abuf[BUFSZ];
+ abuf[BUFSZ] = DUMMY;
int oc_sym;
boolean badopt = FALSE, compat = (strlen(opts) <= 6), use_menu;
value is a synonym for autopickup of all types
(and during initialization, we can't prompt yet) */
flags.pickup = !negated;
- return;
+ return retval;
}
oc_to_str(flags.inv_order, ocl);
use_menu = TRUE;
if (flags.menu_style == MENU_TRADITIONAL
|| flags.menu_style == MENU_COMBINATION) {
use_menu = FALSE;
- Sprintf(qbuf, "New pickup_types: [%s am] (%s)", ocl,
+#if 0 /*JP:T*/
+ Sprintf(qbuf, "New %s: [%s am] (%s)", fullname, ocl,
*tbuf ? tbuf : "all");
+#else
+ Sprintf(qbuf, "\90V\82µ\82¢%s: [%s am] (%s)", fullname, ocl,
+ *tbuf ? tbuf : "all");
+#endif
getlin(qbuf, abuf);
op = mungspaces(abuf);
if (abuf[0] == '\0' || abuf[0] == '\033')
use_menu = TRUE;
}
if (use_menu) {
+#if 0 /*JP*/
(void) choose_classes_menu("Auto-Pickup what?", 1, TRUE, ocl,
tbuf);
+#else
+ (void) choose_classes_menu("\82Ç\82ê\82ð\8e©\93®\8fE\82¢\82É\90Ý\92è\82·\82é\81H", 1, TRUE, ocl,
+ tbuf);
+#endif
op = tbuf;
}
}
if (negated) {
- bad_negation("pickup_types", TRUE);
- return;
+ bad_negation(fullname, TRUE);
+ return FALSE;
}
while (*op == ' ')
op++;
badopt = TRUE;
op++;
}
- if (badopt)
- badoption(opts);
+ if (badopt) {
+ config_error_add("Unknown %s parameter '%s'", fullname, op);
+ return FALSE;
+ }
}
- return;
+ return retval;
}
/* pile limit: when walking over objects, number which triggers
op = string_for_opt(opts, negated);
if ((negated && !op) || (!negated && op))
flags.pile_limit = negated ? 0 : atoi(op);
- else if (negated)
+ else if (negated) {
bad_negation(fullname, TRUE);
- else /* !op */
+ return FALSE;
+ } else /* !op */
flags.pile_limit = PILE_LIMIT_DFLT;
/* sanity check */
if (flags.pile_limit < 0)
flags.pile_limit = PILE_LIMIT_DFLT;
- return;
+ return retval;
}
/* play mode: normal, explore/discovery, or debug/wizard */
if (negated)
bad_negation(fullname, FALSE);
if (duplicate || negated)
- return;
- op = string_for_opt(opts, TRUE);
+ return FALSE;
+ op = string_for_opt(opts, FALSE);
+ if (!op)
+ return FALSE;
if (!strncmpi(op, "normal", 6) || !strcmpi(op, "play")) {
wizard = discover = FALSE;
} else if (!strncmpi(op, "explore", 6)
} else if (!strncmpi(op, "debug", 5) || !strncmpi(op, "wizard", 6)) {
wizard = TRUE, discover = FALSE;
} else {
- raw_printf("Invalid value for \"%s\":%s.", fullname, op);
+ config_error_add("Invalid value for \"%s\":%s", fullname, op);
+ return FALSE;
}
- return;
+ return retval;
}
/* WINCAP
iflags.wc_player_selection = VIA_DIALOG;
else if (!strncmpi(op, "prompt", sizeof("prompt") - 1))
iflags.wc_player_selection = VIA_PROMPTS;
- else
- badoption(opts);
- } else if (negated)
+ else {
+ config_error_add("Unknown %s parameter '%s'", fullname, op);
+ return FALSE;
+ }
+ } else if (negated) {
bad_negation(fullname, TRUE);
- return;
+ return FALSE;
+ }
+ return retval;
}
/* things to disclose at end of game */
- if (match_optname(opts, "disclose", 7, TRUE)) {
+ fullname = "disclose";
+ if (match_optname(opts, fullname, 7, TRUE)) {
/*
* The order that the end_disclose options are stored:
* inventory, attribs, vanquished, genocided,
* and the presence of a i,a,g,v, or c without a prefix
* sets the corresponding value to DISCLOSE_YES_WITHOUT_PROMPT.
*/
- boolean badopt = FALSE;
int idx, prefix_val;
if (duplicate)
complain_about_duplicate(opts, 1);
op = string_for_opt(opts, TRUE);
if (op && negated) {
- bad_negation("disclose", TRUE);
- return;
+ bad_negation(fullname, TRUE);
+ return FALSE;
}
/* "disclose" without a value means "all with prompting"
and negated means "none without prompting" */
flags.end_disclose[num] = negated
? DISCLOSE_NO_WITHOUT_PROMPT
: DISCLOSE_PROMPT_DEFAULT_YES;
- return;
+ return retval;
}
num = 0;
while (*op && num < sizeof flags.end_disclose - 1) {
static char valid_settings[] = {
DISCLOSE_PROMPT_DEFAULT_YES, DISCLOSE_PROMPT_DEFAULT_NO,
- DISCLOSE_YES_WITHOUT_PROMPT, DISCLOSE_NO_WITHOUT_PROMPT, '\0'
+ DISCLOSE_PROMPT_DEFAULT_SPECIAL,
+ DISCLOSE_YES_WITHOUT_PROMPT, DISCLOSE_NO_WITHOUT_PROMPT,
+ DISCLOSE_SPECIAL_WITHOUT_PROMPT, '\0'
};
register char c, *dop;
continue;
}
if (prefix_val != -1) {
+ if (*dop != 'v') {
+ if (prefix_val == DISCLOSE_PROMPT_DEFAULT_SPECIAL)
+ prefix_val = DISCLOSE_PROMPT_DEFAULT_YES;
+ if (prefix_val == DISCLOSE_SPECIAL_WITHOUT_PROMPT)
+ prefix_val = DISCLOSE_YES_WITHOUT_PROMPT;
+ }
flags.end_disclose[idx] = prefix_val;
prefix_val = -1;
} else
prefix_val = c;
} else if (c == ' ') {
; /* do nothing */
- } else
- badopt = TRUE;
+ } else {
+ config_error_add("Unknown %s parameter '%c'", fullname, *op);
+ return FALSE;
+ }
op++;
}
- if (badopt)
- badoption(opts);
- return;
+ return retval;
+ }
+#if 1 /*JP*/
+ if (!strncmpi(opts, "kcode", 3)){
+ if ((op = string_for_env_opt("kcode", opts, FALSE)) != 0){
+ setkcode(*op);
+ }
+ return retval;
}
+#endif
/* scores:5t[op] 5a[round] o[wn] */
- if (match_optname(opts, "scores", 4, TRUE)) {
+ fullname = "scores";
+ if (match_optname(opts, fullname, 4, TRUE)) {
if (duplicate)
complain_about_duplicate(opts, 1);
if (negated) {
- bad_negation("scores", FALSE);
- return;
+ bad_negation(fullname, FALSE);
+ return FALSE;
}
if (!(op = string_for_opt(opts, FALSE)))
- return;
+ return FALSE;
while (*op) {
int inum = 1;
flags.end_own = !negated;
break;
default:
- badoption(opts);
- return;
+ config_error_add("Unknown %s parameter '%s'", fullname, op);
+ return FALSE;
}
while (letter(*++op) || *op == ' ')
continue;
if (*op == '/')
op++;
}
- return;
+ return retval;
}
fullname = "sortloot";
if (match_optname(opts, fullname, 4, TRUE)) {
op = string_for_env_opt(fullname, opts, FALSE);
if (op) {
- switch (tolower(*op)) {
- case 'n':
- case 'l':
- case 'f':
- flags.sortloot = tolower(*op);
+ char c = lowc(*op);
+
+ switch (c) {
+ case 'n': /* none */
+ case 'l': /* loot (pickup) */
+ case 'f': /* full (pickup + invent) */
+ flags.sortloot = c;
break;
default:
- badoption(opts);
- return;
+ config_error_add("Unknown %s parameter '%s'", fullname, op);
+ return FALSE;
}
- }
- return;
+ } else
+ return FALSE;
+ return retval;
}
fullname = "suppress_alert";
if (duplicate)
complain_about_duplicate(opts, 1);
op = string_for_opt(opts, negated);
- if (negated)
+ if (negated) {
bad_negation(fullname, FALSE);
- else if (op)
+ return FALSE;
+ } else if (op)
(void) feature_alert_opts(op, fullname);
- return;
+ return retval;
}
#ifdef VIDEOSHADES
complain_about_duplicate(opts, 1);
if (negated) {
bad_negation(fullname, FALSE);
- return;
+ return FALSE;
} else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) {
- return;
+ return FALSE;
}
- if (!assign_videocolors(opts))
- badoption(opts);
- return;
+ if (!assign_videocolors(opts)) /* TODO: error msg */
+ return FALSE;
+ return retval;
}
/* videoshades:string */
fullname = "videoshades";
complain_about_duplicate(opts, 1);
if (negated) {
bad_negation(fullname, FALSE);
- return;
+ return FALSE;
} else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) {
- return;
+ return FALSE;
}
- if (!assign_videoshades(opts))
- badoption(opts);
- return;
+ if (!assign_videoshades(opts)) /* TODO: error msg */
+ return FALSE;
+ return retval;
}
#endif /* VIDEOSHADES */
#ifdef MSDOS
complain_about_duplicate(opts, 1);
if (negated) {
bad_negation(fullname, FALSE);
- return;
+ return FALSE;
} else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) {
- return;
+ return FALSE;
}
- if (!assign_video(opts))
- badoption(opts);
- return;
+ if (!assign_video(opts)) /* TODO: error msg */
+ return FALSE;
+ return retval;
}
#endif /* NO_TERMS */
/* soundcard:string -- careful not to match boolean 'sound' */
complain_about_duplicate(opts, 1);
if (negated) {
bad_negation(fullname, FALSE);
- return;
+ return FALSE;
} else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) {
- return;
+ return FALSE;
}
- if (!assign_soundcard(opts))
- badoption(opts);
- return;
+ if (!assign_soundcard(opts)) /* TODO: error msg */
+ return FALSE;
+ return retval;
}
#endif /* MSDOS */
else if (!strncmpi(op, "fit_to_screen",
sizeof("fit_to_screen") - 1))
iflags.wc_map_mode = MAP_MODE_ASCII_FIT_TO_SCREEN;
- else
- badoption(opts);
- } else if (negated)
+ else {
+ config_error_add("Unknown %s parameter '%s'", fullname, op);
+ return FALSE;
+ }
+ } else if (negated) {
bad_negation(fullname, TRUE);
- return;
+ return FALSE;
+ }
+ return retval;
}
+
/* WINCAP
* scroll_amount:nn */
fullname = "scroll_amount";
- if (match_optname(opts, fullname, sizeof("scroll_amount") - 1, TRUE)) {
+ if (match_optname(opts, fullname, sizeof "scroll_amount" - 1, TRUE)) {
if (duplicate)
complain_about_duplicate(opts, 1);
op = string_for_opt(opts, negated);
if ((negated && !op) || (!negated && op)) {
iflags.wc_scroll_amount = negated ? 1 : atoi(op);
- } else if (negated)
+ } else if (negated) {
bad_negation(fullname, TRUE);
- return;
+ return FALSE;
+ }
+ return retval;
}
+
/* WINCAP
* scroll_margin:nn */
fullname = "scroll_margin";
- if (match_optname(opts, fullname, sizeof("scroll_margin") - 1, TRUE)) {
+ if (match_optname(opts, fullname, sizeof "scroll_margin" - 1, TRUE)) {
if (duplicate)
complain_about_duplicate(opts, 1);
op = string_for_opt(opts, negated);
if ((negated && !op) || (!negated && op)) {
iflags.wc_scroll_margin = negated ? 5 : atoi(op);
- } else if (negated)
+ } else if (negated) {
bad_negation(fullname, TRUE);
- return;
+ return FALSE;
+ }
+ return retval;
}
+
fullname = "subkeyvalue";
if (match_optname(opts, fullname, 5, TRUE)) {
/* no duplicate complaint here */
if (negated) {
bad_negation(fullname, FALSE);
+ return FALSE;
} else {
#if defined(WIN32)
op = string_for_opt(opts, 0);
+ if (!op)
+ return FALSE;
map_subkeyvalue(op);
#endif
}
- return;
+ return retval;
}
+
/* WINCAP
* tile_width:nn */
fullname = "tile_width";
op = string_for_opt(opts, negated);
if ((negated && !op) || (!negated && op)) {
iflags.wc_tile_width = negated ? 0 : atoi(op);
- } else if (negated)
+ } else if (negated) {
bad_negation(fullname, TRUE);
- return;
+ return FALSE;
+ }
+ return retval;
}
/* WINCAP
* tile_file:name */
if ((op = string_for_opt(opts, FALSE)) != 0) {
if (iflags.wc_tile_file)
free(iflags.wc_tile_file);
- iflags.wc_tile_file = (char *) alloc(strlen(op) + 1);
- Strcpy(iflags.wc_tile_file, op);
- }
- return;
+ iflags.wc_tile_file = dupstr(op);
+ } else
+ return FALSE;
+ return retval;
}
/* WINCAP
* tile_height:nn */
op = string_for_opt(opts, negated);
if ((negated && !op) || (!negated && op)) {
iflags.wc_tile_height = negated ? 0 : atoi(op);
- } else if (negated)
+ } else if (negated) {
bad_negation(fullname, TRUE);
- return;
+ return FALSE;
+ }
+ return retval;
}
+
/* WINCAP
* vary_msgcount:nn */
fullname = "vary_msgcount";
op = string_for_opt(opts, negated);
if ((negated && !op) || (!negated && op)) {
iflags.wc_vary_msgcount = negated ? 0 : atoi(op);
- } else if (negated)
+ } else if (negated) {
bad_negation(fullname, TRUE);
- return;
+ return FALSE;
+ }
+ return retval;
}
+
+ /*
+ * windowtype: option to choose the interface for binaries built
+ * with support for more than one interface (tty + X11, for instance).
+ *
+ * Ideally, 'windowtype' should be processed first, because it
+ * causes the wc_ and wc2_ flags to be set up.
+ * For user, making it be first in a config file is trivial, use
+ * OPTIONS=windowtype:Foo
+ * as the first non-comment line of the file.
+ * Making it first in NETHACKOPTIONS requires it to be at the _end_
+ * because option strings are processed from right to left.
+ */
fullname = "windowtype";
if (match_optname(opts, fullname, 3, TRUE)) {
if (duplicate)
complain_about_duplicate(opts, 1);
if (negated) {
bad_negation(fullname, FALSE);
- return;
+ return FALSE;
} else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
char buf[WINTYPELEN];
+
nmcpy(buf, op, WINTYPELEN);
choose_windows(buf);
- }
- return;
+ } else
+ return FALSE;
+ return retval;
}
+
#ifdef WINCHAIN
fullname = "windowchain";
if (match_optname(opts, fullname, 3, TRUE)) {
if (negated) {
bad_negation(fullname, FALSE);
- return;
+ return FALSE;
} else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
char buf[WINTYPELEN];
+
nmcpy(buf, op, WINTYPELEN);
addto_windowchain(buf);
- }
- return;
+ } else
+ return FALSE;
+ return retval;
}
#endif
if (duplicate)
complain_about_duplicate(opts, 1);
if ((op = string_for_opt(opts, FALSE)) != 0) {
- if (!wc_set_window_colors(op))
- badoption(opts);
+ if (!wc_set_window_colors(op)) /* TODO: error msg*/
+ return FALSE;
} else if (negated)
bad_negation(fullname, TRUE);
- return;
+ return retval;
}
/* menustyle:traditional or combination or full or partial */
- if (match_optname(opts, "menustyle", 4, TRUE)) {
+ fullname = "menustyle";
+ if (match_optname(opts, fullname, 4, TRUE)) {
int tmp;
boolean val_required = (strlen(opts) > 5 && !negated);
complain_about_duplicate(opts, 1);
if (!(op = string_for_opt(opts, !val_required))) {
if (val_required)
- return; /* string_for_opt gave feedback */
+ return FALSE; /* string_for_opt gave feedback */
tmp = negated ? 'n' : 'f';
} else {
- tmp = tolower(*op);
+ tmp = lowc(*op);
}
switch (tmp) {
case 'n': /* none */
- case 't': /* traditional */
+ case 't': /* traditional: prompt for class(es) by symbol,
+ prompt for each item within class(es) one at a time */
flags.menu_style = MENU_TRADITIONAL;
break;
- case 'c': /* combo: trad.class sel+menu */
+ case 'c': /* combination: prompt for class(es) by symbol,
+ choose items within selected class(es) by menu */
flags.menu_style = MENU_COMBINATION;
break;
- case 'p': /* partial: no class menu */
- flags.menu_style = MENU_PARTIAL;
- break;
- case 'f': /* full: class menu + menu */
+ case 'f': /* full: choose class(es) by first menu,
+ choose items within selected class(es) by second menu */
flags.menu_style = MENU_FULL;
break;
+ case 'p': /* partial: skip class filtering,
+ choose items among all classes by menu */
+ flags.menu_style = MENU_PARTIAL;
+ break;
default:
- badoption(opts);
+ config_error_add("Unknown %s parameter '%s'", fullname, op);
+ return FALSE;
}
- return;
+ return retval;
}
fullname = "menu_headings";
if (match_optname(opts, fullname, 12, TRUE)) {
+ int tmpattr;
+
if (duplicate)
complain_about_duplicate(opts, 1);
if (negated) {
bad_negation(fullname, FALSE);
- return;
+ return FALSE;
} else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) {
- return;
+ return FALSE;
}
- for (i = 0; i < SIZE(attrnames); i++)
- if (!strcmpi(opts, attrnames[i].name)) {
- iflags.menu_headings = attrnames[i].attr;
- return;
- }
- badoption(opts);
- return;
+ tmpattr = match_str2attr(opts, TRUE);
+ if (tmpattr == -1)
+ return FALSE;
+ else
+ iflags.menu_headings = tmpattr;
+ return retval;
}
/* check for menu command mapping */
- for (i = 0; i < NUM_MENU_CMDS; i++) {
+ for (i = 0; i < SIZE(default_menu_cmd_info); i++) {
fullname = default_menu_cmd_info[i].name;
if (duplicate)
complain_about_duplicate(opts, 1);
if (match_optname(opts, fullname, (int) strlen(fullname), TRUE)) {
if (negated) {
bad_negation(fullname, FALSE);
+ return FALSE;
} else if ((op = string_for_opt(opts, FALSE)) != 0) {
- int j;
char c, op_buf[BUFSZ];
- boolean isbad = FALSE;
escapes(op, op_buf);
c = *op_buf;
- if (c == 0 || c == '\r' || c == '\n' || c == '\033'
- || c == ' ' || digit(c) || (letter(c) && c != '@'))
- isbad = TRUE;
- else /* reject default object class symbols */
- for (j = 1; j < MAXOCLASSES; j++)
- if (c == def_oc_syms[i].sym) {
- isbad = TRUE;
- break;
- }
-
- if (isbad)
- badoption(opts);
- else
+ if (illegal_menu_cmd_key(c)) {
+ return FALSE;
+ } else
add_menu_cmd_alias(c, default_menu_cmd_info[i].cmd);
}
- return;
+ return retval;
}
}
-#if defined(STATUS_VIA_WINDOWPORT) && defined(STATUS_HILITES)
+
/* hilite fields in status prompt */
- if (match_optname(opts, "hilite_status", 13, TRUE)) {
+ fullname = "hilite_status";
+ if (match_optname(opts, fullname, 13, TRUE)) {
+#ifdef STATUS_HILITES
if (duplicate)
complain_about_duplicate(opts, 1);
op = string_for_opt(opts, TRUE);
if (op && negated) {
- clear_status_hilites(tfrom_file);
- return;
+ clear_status_hilites();
+ return retval;
} else if (!op) {
- /* a value is mandatory */
- badoption(opts);
- return;
+ config_error_add("Value is mandatory for hilite_status");
+ return FALSE;
}
- if (!set_status_hilites(op, tfrom_file))
- badoption(opts);
- return;
+ if (!parse_status_hl1(op, tfrom_file))
+ return FALSE;
+ return retval;
+#else
+ config_error_add("'%s' is not supported", fullname);
+ return FALSE;
+#endif
}
+
+ /* control over whether highlights should be displayed, and for how long */
+ fullname = "statushilites";
+ if (match_optname(opts, fullname, 9, TRUE)) {
+#ifdef STATUS_HILITES
+ if (negated) {
+ iflags.hilite_delta = 0L;
+ } else {
+ op = string_for_opt(opts, TRUE);
+ iflags.hilite_delta = (!op || !*op) ? 3L : atol(op);
+ if (iflags.hilite_delta < 0L)
+ iflags.hilite_delta = 1L;
+ }
+ if (!tfrom_file)
+ reset_status_hilites();
+ return retval;
+#else
+ config_error_add("'%s' is not supported", fullname);
+ return FALSE;
#endif
+ }
-#if defined(BACKWARD_COMPAT)
fullname = "DECgraphics";
if (match_optname(opts, fullname, 3, TRUE)) {
+#ifdef BACKWARD_COMPAT
boolean badflag = FALSE;
if (duplicate)
switch_symbols(TRUE);
}
if (badflag) {
- pline("Failure to load symbol set %s.", fullname);
- wait_synch();
+ config_error_add("Failure to load symbol set %s.", fullname);
+ return FALSE;
}
}
- return;
- }
+ return retval;
+#else
+ config_error_add("'%s' no longer supported; use 'symset:%s' instead",
+ fullname, fullname);
+ return FALSE;
+#endif
+ } /* "DECgraphics" */
+
fullname = "IBMgraphics";
if (match_optname(opts, fullname, 3, TRUE)) {
+#ifdef BACKWARD_COMPAT
const char *sym_name = fullname;
boolean badflag = FALSE;
}
}
if (badflag) {
- pline("Failure to load symbol set %s.", sym_name);
- wait_synch();
+ config_error_add("Failure to load symbol set %s.", sym_name);
+ return FALSE;
} else {
switch_symbols(TRUE);
if (!initial && Is_rogue_level(&u.uz))
assign_graphics(ROGUESET);
}
}
- return;
- }
+ return retval;
+#else
+ config_error_add("'%s' no longer supported; use 'symset:%s' instead",
+ fullname, fullname);
+ return FALSE;
#endif
-#ifdef MAC_GRAPHICS_ENV
+ } /* "IBMgraphics" */
+
fullname = "MACgraphics";
if (match_optname(opts, fullname, 3, TRUE)) {
+#if defined(MAC_GRAPHICS_ENV) && defined(BACKWARD_COMPAT)
boolean badflag = FALSE;
if (duplicate)
}
}
if (badflag) {
- pline("Failure to load symbol set %s.", fullname);
- wait_synch();
+ config_error_add("Failure to load symbol set %s.", fullname);
+ return FALSE;
} else {
switch_symbols(TRUE);
if (!initial && Is_rogue_level(&u.uz))
assign_graphics(ROGUESET);
}
}
- return;
- }
+ return retval;
+#else /* !(MAC_GRAPHICS_ENV && BACKWARD_COMPAT) */
+ config_error_add("'%s' %s; use 'symset:%s' instead",
+ fullname,
+#ifdef MAC_GRAPHICS_ENV /* implies BACKWARD_COMPAT is not defined */
+ "no longer supported",
+#else
+ "is not supported",
#endif
+ fullname);
+ return FALSE;
+#endif /* ?(MAC_GRAPHICS_ENV && BACKWARD_COMPAT) */
+ } /* "MACgraphics" */
/* OK, if we still haven't recognized the option, check the boolean
* options list
*/
for (i = 0; boolopt[i].name; i++) {
- if (match_optname(opts, boolopt[i].name, 3, FALSE)) {
+ if (match_optname(opts, boolopt[i].name, 3, TRUE)) {
/* options that don't exist */
if (!boolopt[i].addr) {
if (!initial && !negated)
pline_The("\"%s\" option is not available.",
boolopt[i].name);
- return;
+ return retval;
}
/* options that must come from config file */
if (!initial && (boolopt[i].optflags == SET_IN_FILE)) {
rejectoption(boolopt[i].name);
- return;
+ return retval;
+ }
+
+ op = string_for_opt(opts, TRUE);
+
+ if (op) {
+ if (negated) {
+ config_error_add(
+ "Negated boolean '%s' should not have a parameter",
+ boolopt[i].name);
+ return FALSE;
+ }
+ if (!strcmp(op, "true") || !strcmp(op, "yes")) {
+ negated = FALSE;
+ } else if (!strcmp(op, "false") || !strcmp(op, "no")) {
+ negated = TRUE;
+ } else {
+ config_error_add("Illegal parameter for a boolean");
+ return FALSE;
+ }
}
*(boolopt[i].addr) = !negated;
/* 0 means boolean opts */
if (duplicate_opt_detection(boolopt[i].name, 0))
complain_about_duplicate(boolopt[i].name, 0);
-
#ifdef RLECOMP
- if ((boolopt[i].addr) == &iflags.rlecomp) {
- if (*boolopt[i].addr)
- set_savepref("rlecomp");
- else
- set_savepref("!rlecomp");
- }
+ if (boolopt[i].addr == &iflags.rlecomp)
+ set_savepref(iflags.rlecomp ? "rlecomp" : "!rlecomp");
#endif
#ifdef ZEROCOMP
- if ((boolopt[i].addr) == &iflags.zerocomp) {
- if (*boolopt[i].addr)
- set_savepref("zerocomp");
- else
- set_savepref("externalcomp");
- }
+ if (boolopt[i].addr == &iflags.zerocomp)
+ set_savepref(iflags.zerocomp ? "zerocomp" : "externalcomp");
#endif
+ if (boolopt[i].addr == &iflags.wc_ascii_map) {
+ /* toggling ascii_map; set tiled_map to its opposite;
+ what does it mean to turn off ascii map if tiled map
+ isn't supported? -- right now, we do nothing */
+ iflags.wc_tiled_map = negated;
+ } else if (boolopt[i].addr == &iflags.wc_tiled_map) {
+ /* toggling tiled_map; set ascii_map to its opposite;
+ as with ascii_map, what does it mean to turn off tiled
+ map if ascii map isn't supported? */
+ iflags.wc_ascii_map = negated;
+ }
/* only do processing below if setting with doset() */
if (initial)
- return;
+ return retval;
- if ((boolopt[i].addr) == &flags.time
- || (boolopt[i].addr) == &flags.showexp
+ if (boolopt[i].addr == &flags.time
#ifdef SCORE_ON_BOTL
- || (boolopt[i].addr) == &flags.showscore
+ || boolopt[i].addr == &flags.showscore
#endif
- ) {
-#ifdef STATUS_VIA_WINDOWPORT
+ || boolopt[i].addr == &flags.showexp) {
+#ifdef STATUS_HILITES
status_initialize(REASSESS_ONLY);
#endif
context.botl = TRUE;
- } else if ((boolopt[i].addr) == &flags.invlet_constant) {
+ } else if (boolopt[i].addr == &flags.invlet_constant) {
if (flags.invlet_constant)
reassign();
- } else if (((boolopt[i].addr) == &flags.lit_corridor)
- || ((boolopt[i].addr) == &flags.dark_room)) {
+ } else if (boolopt[i].addr == &flags.lit_corridor
+ || boolopt[i].addr == &flags.dark_room) {
/*
* All corridor squares seen via night vision or
* candles & lamps change. Update them by calling
vision_full_recalc = 1; /* delayed recalc */
if (iflags.use_color)
need_redraw = TRUE; /* darkroom refresh */
- } else if ((boolopt[i].addr) == &iflags.use_inverse
- || (boolopt[i].addr) == &flags.showrace
- || (boolopt[i].addr) == &iflags.hilite_pet) {
+ } else if (boolopt[i].addr == &flags.showrace
+ || boolopt[i].addr == &iflags.use_inverse
+ || boolopt[i].addr == &iflags.hilite_pile
+ || boolopt[i].addr == &iflags.hilite_pet
+ || boolopt[i].addr == &iflags.wc_ascii_map
+ || boolopt[i].addr == &iflags.wc_tiled_map) {
need_redraw = TRUE;
+#ifdef STATUS_HILITES
+ } else if (boolopt[i].addr == &iflags.wc2_hitpointbar) {
+ status_initialize(REASSESS_ONLY);
+ need_redraw = TRUE;
+#endif
#ifdef TEXTCOLOR
- } else if ((boolopt[i].addr) == &iflags.use_color) {
+ } else if (boolopt[i].addr == &iflags.use_color) {
need_redraw = TRUE;
#ifdef TOS
- if ((boolopt[i].addr) == &iflags.use_color && iflags.BIOS) {
+ if (iflags.BIOS) {
if (colors_changed)
restore_colors();
else
#endif
#endif /* TEXTCOLOR */
}
- return;
+ return retval;
+ }
+ }
+
+ /* Is it a symbol? */
+ if (strstr(opts, "S_") == opts && parsesymbols(opts)) {
+ switch_symbols(TRUE);
+ check_gold_symbol();
+ return retval;
+ }
+
+ /* out of valid options */
+ config_error_add("Unknown option '%s'", opts);
+ return FALSE;
+}
+
+/* parse key:command */
+boolean
+parsebindings(bindings)
+char* bindings;
+{
+ char *bind;
+ char key;
+ int i;
+ boolean ret = FALSE;
+
+ /* break off first binding from the rest; parse the rest */
+ if ((bind = index(bindings, ',')) != 0) {
+ *bind++ = 0;
+ ret |= parsebindings(bind);
+ }
+
+ /* parse a single binding: first split around : */
+ if (! (bind = index(bindings, ':')))
+ return FALSE; /* it's not a binding */
+ *bind++ = 0;
+
+ /* read the key to be bound */
+ key = txt2key(bindings);
+ if (!key) {
+ config_error_add("Unknown key binding key '%s'", bindings);
+ return FALSE;
+ }
+
+ bind = trimspaces(bind);
+
+ /* is it a special key? */
+ if (bind_specialkey(key, bind))
+ return TRUE;
+
+ /* is it a menu command? */
+ for (i = 0; i < SIZE(default_menu_cmd_info); i++) {
+ if (!strcmp(default_menu_cmd_info[i].name, bind)) {
+ if (illegal_menu_cmd_key(key)) {
+ config_error_add("Bad menu key %s:%s", visctrl(key), bind);
+ return FALSE;
+ } else
+ add_menu_cmd_alias(key, default_menu_cmd_info[i].cmd);
+ return TRUE;
}
}
- /* out of valid options */
- badoption(opts);
+ /* extended command? */
+ if (!bind_key(key, bind)) {
+ config_error_add("Unknown key binding command '%s'", bind);
+ return FALSE;
+ }
+ return TRUE;
}
static NEARDATA const char *menutype[] = { "traditional", "combination",
}
}
+char
+get_menu_cmd_key(ch)
+char ch;
+{
+ char *found = index(mapped_menu_op, ch);
+
+ if (found) {
+ int idx = (int) (found - mapped_menu_op);
+
+ ch = mapped_menu_cmds[idx];
+ }
+ return ch;
+}
+
/*
* Map the given character to its corresponding menu command. If it
* doesn't match anything, just return the original.
char ch;
{
char *found = index(mapped_menu_cmds, ch);
+
if (found) {
int idx = (int) (found - mapped_menu_cmds);
+
ch = mapped_menu_op[idx];
}
return ch;
}
+void
+show_menu_controls(win, dolist)
+winid win;
+boolean dolist;
+{
+ char buf[BUFSZ];
+
+ putstr(win, 0, "Menu control keys:");
+ if (dolist) {
+ int i;
+
+ for (i = 0; i < SIZE(default_menu_cmd_info); i++) {
+ Sprintf(buf, "%-8s %s",
+ visctrl(get_menu_cmd_key(default_menu_cmd_info[i].cmd)),
+ default_menu_cmd_info[i].desc);
+ putstr(win, 0, buf);
+ }
+ } else {
+ putstr(win, 0, "");
+ putstr(win, 0, " Page All items");
+ Sprintf(buf, " Select %s %s",
+ visctrl(get_menu_cmd_key(MENU_SELECT_PAGE)),
+ visctrl(get_menu_cmd_key(MENU_SELECT_ALL)));
+ putstr(win, 0, buf);
+ Sprintf(buf, "Deselect %s %s",
+ visctrl(get_menu_cmd_key(MENU_UNSELECT_PAGE)),
+ visctrl(get_menu_cmd_key(MENU_UNSELECT_ALL)));
+ putstr(win, 0, buf);
+ Sprintf(buf, " Invert %s %s",
+ visctrl(get_menu_cmd_key(MENU_INVERT_PAGE)),
+ visctrl(get_menu_cmd_key(MENU_INVERT_ALL)));
+ putstr(win, 0, buf);
+ putstr(win, 0, "");
+ Sprintf(buf, " Go to %s Next page",
+ visctrl(get_menu_cmd_key(MENU_NEXT_PAGE)));
+ putstr(win, 0, buf);
+ Sprintf(buf, " %s Previous page",
+ visctrl(get_menu_cmd_key(MENU_PREVIOUS_PAGE)));
+ putstr(win, 0, buf);
+ Sprintf(buf, " %s First page",
+ visctrl(get_menu_cmd_key(MENU_FIRST_PAGE)));
+ putstr(win, 0, buf);
+ Sprintf(buf, " %s Last page",
+ visctrl(get_menu_cmd_key(MENU_LAST_PAGE)));
+ putstr(win, 0, buf);
+ putstr(win, 0, "");
+ Sprintf(buf, " %s Search and toggle matching entries",
+ visctrl(get_menu_cmd_key(MENU_SEARCH)));
+ putstr(win, 0, buf);
+ }
+}
+
#if defined(MICRO) || defined(MAC) || defined(WIN32)
#define OPTIONS_HEADING "OPTIONS"
#else
#define OPTIONS_HEADING "NETHACKOPTIONS"
#endif
-static char fmtstr_doset_add_menu[] = "%s%-15s [%s] ";
-static char fmtstr_doset_add_menu_tab[] = "%s\t[%s]";
+static char fmtstr_doset[] = "%s%-15s [%s] ";
+static char fmtstr_doset_tab[] = "%s\t[%s]";
+static char n_currently_set[] = "(%d currently set)";
+/* doset('O' command) menu entries for compound options */
STATIC_OVL void
doset_add_menu(win, option, indexoffset)
winid win; /* window to add to */
}
/* " " replaces "a - " -- assumes menus follow that style */
if (!iflags.menu_tab_sep)
- Sprintf(buf, fmtstr_doset_add_menu, any.a_int ? "" : " ", option,
+ Sprintf(buf, fmtstr_doset, any.a_int ? "" : " ", option,
value);
else
- Sprintf(buf, fmtstr_doset_add_menu_tab, option, value);
+ Sprintf(buf, fmtstr_doset_tab, option, value);
add_menu(win, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, MENU_UNSELECTED);
}
-/* Changing options via menu by Per Liboriussen */
-int
-doset()
+STATIC_OVL void
+opts_add_others(win, name, id, bufx, nset)
+winid win;
+const char *name;
+int id;
+char *bufx;
+int nset;
{
char buf[BUFSZ], buf2[BUFSZ];
+ anything any = zeroany;
+
+ any.a_int = id;
+ if (!bufx)
+ Sprintf(buf2, n_currently_set, nset);
+ else
+ Sprintf(buf2, "%s", bufx);
+ if (!iflags.menu_tab_sep)
+ Sprintf(buf, fmtstr_doset, any.a_int ? "" : " ",
+ name, buf2);
+ else
+ Sprintf(buf, fmtstr_doset_tab, name, buf2);
+ add_menu(win, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, MENU_UNSELECTED);
+}
+
+int
+count_apes(VOID_ARGS)
+{
+ return count_ape_maps((int *) 0, (int *) 0);
+}
+
+enum opt_other_enums {
+ OPT_OTHER_MSGTYPE = -4,
+ OPT_OTHER_MENUCOLOR = -3,
+ OPT_OTHER_STATHILITE = -2,
+ OPT_OTHER_APEXC = -1
+ /* these must be < 0 */
+};
+
+static struct other_opts {
+ const char *name;
+ int optflags;
+ enum opt_other_enums code;
+ int NDECL((*othr_count_func));
+} othropt[] = {
+ { "autopickup exceptions", SET_IN_GAME, OPT_OTHER_APEXC, count_apes },
+ { "menucolors", SET_IN_GAME, OPT_OTHER_MENUCOLOR, count_menucolors },
+ { "message types", SET_IN_GAME, OPT_OTHER_MSGTYPE, msgtype_count },
+#ifdef STATUS_HILITES
+ { "status hilite rules", SET_IN_GAME, OPT_OTHER_STATHILITE,
+ count_status_hilites },
+#endif
+ { (char *) 0, 0, (enum opt_other_enums) 0 },
+};
+
+/* the 'O' command */
+int
+doset() /* changing options via menu by Per Liboriussen */
+{
+ static boolean made_fmtstr = FALSE;
+ char buf[BUFSZ], buf2[BUFSZ] = DUMMY;
+ const char *name;
int i = 0, pass, boolcount, pick_cnt, pick_idx, opt_indx;
boolean *bool_p;
winid tmpwin;
anything any;
menu_item *pick_list;
- int indexoffset, startpass, endpass;
+ int indexoffset, startpass, endpass, optflags;
boolean setinitial = FALSE, fromfile = FALSE;
- int biggest_name = 0;
- const char *n_currently_set = "(%d currently set)";
+ unsigned longest_name_len;
tmpwin = create_nhwindow(NHW_MENU);
start_menu(tmpwin);
+#ifdef notyet /* SYSCF */
+ /* XXX I think this is still fragile. Fixing initial/from_file and/or
+ changing the SET_* etc to bitmaps will let me make this better. */
+ if (wizard)
+ startpass = SET_IN_SYS;
+ else
+#endif
+ startpass = DISP_IN_GAME;
+ endpass = (wizard) ? SET_IN_WIZGAME : SET_IN_GAME;
+
+ if (!made_fmtstr && !iflags.menu_tab_sep) {
+ /* spin through the options to find the longest name
+ and adjust the format string accordingly */
+ longest_name_len = 0;
+ for (pass = 0; pass <= 2; pass++)
+ for (i = 0; (name = ((pass == 0)
+ ? boolopt[i].name
+ : (pass == 1)
+ ? compopt[i].name
+ : othropt[i].name)) != 0; i++) {
+ if (pass == 0 && !boolopt[i].addr)
+ continue;
+ optflags = (pass == 0) ? boolopt[i].optflags
+ : (pass == 1)
+ ? compopt[i].optflags
+ : othropt[i].optflags;
+ if (optflags < startpass || optflags > endpass)
+ continue;
+ if ((is_wc_option(name) && !wc_supported(name))
+ || (is_wc2_option(name) && !wc2_supported(name)))
+ continue;
+
+ if (strlen(name) > longest_name_len)
+ longest_name_len = strlen(name);
+ }
+ Sprintf(fmtstr_doset, "%%s%%-%us [%%s]", longest_name_len);
+ made_fmtstr = TRUE;
+ }
+
any = zeroany;
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, iflags.menu_headings,
+/*JP
"Booleans (selecting will toggle value):", MENU_UNSELECTED);
+*/
+ "\90^\8bU\83I\83v\83V\83\87\83\93 (\91I\91ð\82·\82é\82Æ\92l\82ª\90Ø\82è\91Ö\82í\82è\82Ü\82·)\81F", MENU_UNSELECTED);
any.a_int = 0;
/* first list any other non-modifiable booleans, then modifiable ones */
for (pass = 0; pass <= 1; pass++)
- for (i = 0; boolopt[i].name; i++)
+ for (i = 0; (name = boolopt[i].name) != 0; i++)
if ((bool_p = boolopt[i].addr) != 0
- && ((boolopt[i].optflags == DISP_IN_GAME && pass == 0)
- || (boolopt[i].optflags == SET_IN_GAME && pass == 1))) {
+ && ((boolopt[i].optflags <= DISP_IN_GAME && pass == 0)
+ || (boolopt[i].optflags >= SET_IN_GAME && pass == 1))) {
if (bool_p == &flags.female)
continue; /* obsolete */
- if (bool_p == &iflags.sanity_check && !wizard)
- continue;
- if (bool_p == &iflags.menu_tab_sep && !wizard)
+ if (boolopt[i].optflags == SET_IN_WIZGAME && !wizard)
continue;
- if (is_wc_option(boolopt[i].name)
- && !wc_supported(boolopt[i].name))
- continue;
- if (is_wc2_option(boolopt[i].name)
- && !wc2_supported(boolopt[i].name))
+ if ((is_wc_option(name) && !wc_supported(name))
+ || (is_wc2_option(name) && !wc2_supported(name)))
continue;
+
any.a_int = (pass == 0) ? 0 : i + 1;
if (!iflags.menu_tab_sep)
- Sprintf(buf, "%s%-17s [%s]", pass == 0 ? " " : "",
- boolopt[i].name, *bool_p ? "true" : "false");
+ Sprintf(buf, fmtstr_doset, (pass == 0) ? " " : "",
+ name, *bool_p ? "true" : "false");
else
- Sprintf(buf, "%s\t[%s]", boolopt[i].name,
- *bool_p ? "true" : "false");
+ Sprintf(buf, fmtstr_doset_tab,
+ name, *bool_p ? "true" : "false");
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf,
MENU_UNSELECTED);
}
indexoffset = boolcount;
any = zeroany;
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, "", MENU_UNSELECTED);
+#if 0 /*JP*/
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, iflags.menu_headings,
"Compounds (selecting will prompt for new value):",
MENU_UNSELECTED);
-
-#ifdef notyet /* SYSCF */
- /* XXX I think this is still fragile. Fixing initial/from_file and/or
- changing
- the SET_* etc to bitmaps will let me make this better. */
- if (wizard)
- startpass = SET_IN_SYS;
- else
+#else
+ add_menu(tmpwin, NO_GLYPH, &any, 0, 0, iflags.menu_headings,
+ "\95¶\8e\9a\97ñ\83I\83v\83V\83\87\83\93 (\91I\91ð\82·\82é\82Æ\90V\82µ\82¢\92l\82Ì\93ü\97Í\82ð\8b\81\82ß\82Ü\82·)\81F",
+ MENU_UNSELECTED);
#endif
- startpass = DISP_IN_GAME;
- endpass = SET_IN_GAME;
-
- /* spin through the options to find the biggest name
- and adjust the format string accordingly if needed */
- biggest_name = 0;
- for (i = 0; compopt[i].name; i++)
- if (compopt[i].optflags >= startpass && compopt[i].optflags <= endpass
- && strlen(compopt[i].name) > (unsigned) biggest_name)
- biggest_name = (int) strlen(compopt[i].name);
- if (biggest_name > 30)
- biggest_name = 30;
- if (!iflags.menu_tab_sep)
- Sprintf(fmtstr_doset_add_menu, "%%s%%-%ds [%%s]", biggest_name);
- /* deliberately put `playmode', `name', `role', `race', `gender' first
- (also alignment if anything ever comes before it in compopt[]) */
+ /* deliberately put playmode, name, role+race+gender+align first */
doset_add_menu(tmpwin, "playmode", 0);
doset_add_menu(tmpwin, "name", 0);
doset_add_menu(tmpwin, "role", 0);
doset_add_menu(tmpwin, "race", 0);
doset_add_menu(tmpwin, "gender", 0);
+ doset_add_menu(tmpwin, "align", 0);
for (pass = startpass; pass <= endpass; pass++)
- for (i = 0; compopt[i].name; i++)
+ for (i = 0; (name = compopt[i].name) != 0; i++)
if (compopt[i].optflags == pass) {
- if (!strcmp(compopt[i].name, "playmode")
- || !strcmp(compopt[i].name, "name")
- || !strcmp(compopt[i].name, "role")
- || !strcmp(compopt[i].name, "race")
- || !strcmp(compopt[i].name, "gender"))
+ if (!strcmp(name, "playmode") || !strcmp(name, "name")
+ || !strcmp(name, "role") || !strcmp(name, "race")
+ || !strcmp(name, "gender") || !strcmp(name, "align"))
continue;
- else if (is_wc_option(compopt[i].name)
- && !wc_supported(compopt[i].name))
+ if ((is_wc_option(name) && !wc_supported(name))
+ || (is_wc2_option(name) && !wc2_supported(name)))
continue;
- else if (is_wc2_option(compopt[i].name)
- && !wc2_supported(compopt[i].name))
- continue;
- else
- doset_add_menu(tmpwin, compopt[i].name,
- (pass == DISP_IN_GAME) ? 0 : indexoffset);
+
+ doset_add_menu(tmpwin, name,
+ (pass == DISP_IN_GAME) ? 0 : indexoffset);
}
- any.a_int = -4;
- Sprintf(buf2, n_currently_set, msgtype_count());
- Sprintf(buf, fmtstr_doset_add_menu, any.a_int ? "" : " ",
- "message types", buf2);
- add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, MENU_UNSELECTED);
- any.a_int = -3;
- Sprintf(buf2, n_currently_set, count_menucolors());
- Sprintf(buf, fmtstr_doset_add_menu, any.a_int ? "" : " ",
- "menucolors", buf2);
- add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, MENU_UNSELECTED);
-#ifdef STATUS_VIA_WINDOWPORT
-#ifdef STATUS_HILITES
- any.a_int = -2;
- get_status_hilites(buf2, 60);
- if (!*buf2)
- Sprintf(buf2, "%s", "(none)");
- if (!iflags.menu_tab_sep)
- Sprintf(buf, fmtstr_doset_add_menu, any.a_int ? "" : " ",
- "status_hilites", buf2);
- else
- Sprintf(buf, fmtstr_doset_add_menu_tab, "status_hilites", buf2);
- add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, MENU_UNSELECTED);
-#endif
-#endif
- any.a_int = -1;
- Sprintf(buf2, n_currently_set, count_ape_maps((int *) 0, (int *) 0));
- Sprintf(buf, fmtstr_doset_add_menu, any.a_int ? "" : " ",
- "autopickup exceptions", buf2);
- add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, MENU_UNSELECTED);
+
+ any = zeroany;
+ add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, "", MENU_UNSELECTED);
+ add_menu(tmpwin, NO_GLYPH, &any, 0, 0, iflags.menu_headings,
+ "Other settings:", MENU_UNSELECTED);
+
+ for (i = 0; (name = othropt[i].name) != 0; i++) {
+ if ((is_wc_option(name) && !wc_supported(name))
+ || (is_wc2_option(name) && !wc2_supported(name)))
+ continue;
+ opts_add_others(tmpwin, name, othropt[i].code,
+ (char *) 0, othropt[i].othr_count_func());
+ }
+
#ifdef PREFIXES_IN_USE
any = zeroany;
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, "", MENU_UNSELECTED);
for (i = 0; i < PREFIX_COUNT; i++)
doset_add_menu(tmpwin, fqn_prefix_names[i], 0);
#endif
+/*JP
end_menu(tmpwin, "Set what options?");
+*/
+ end_menu(tmpwin, "\82Ç\82Ì\83I\83v\83V\83\87\83\93\82ð\90Ý\92è\82µ\82Ü\82·\82©\81H");
need_redraw = FALSE;
if ((pick_cnt = select_menu(tmpwin, PICK_ANY, &pick_list)) > 0) {
/*
*/
for (pick_idx = 0; pick_idx < pick_cnt; ++pick_idx) {
opt_indx = pick_list[pick_idx].item.a_int - 1;
- if (opt_indx == -2) {
- /* -2 due to -1 offset for select_menu() */
+ if (opt_indx < -1)
+ opt_indx++; /* -1 offset for select_menu() */
+ if (opt_indx == OPT_OTHER_APEXC) {
(void) special_handling("autopickup_exception", setinitial,
fromfile);
-#ifdef STATUS_VIA_WINDOWPORT
#ifdef STATUS_HILITES
- } else if (opt_indx == -3) {
- /* -3 due to -1 offset for select_menu() */
+ } else if (opt_indx == OPT_OTHER_STATHILITE) {
if (!status_hilite_menu()) {
pline("Bad status hilite(s) specified.");
} else {
- if (wc2_supported("status_hilites"))
- preference_update("status_hilites");
+ if (wc2_supported("hilite_status"))
+ preference_update("hilite_status");
}
#endif
-#endif
- } else if (opt_indx == -4) {
+ } else if (opt_indx == OPT_OTHER_MENUCOLOR) {
(void) special_handling("menucolors", setinitial,
fromfile);
- } else if (opt_indx == -5) {
+ } else if (opt_indx == OPT_OTHER_MSGTYPE) {
(void) special_handling("msgtype", setinitial, fromfile);
} else if (opt_indx < boolcount) {
/* boolean option */
if (!special_handling(compopt[opt_indx].name, setinitial,
fromfile)) {
+/*JP
Sprintf(buf, "Set %s to what?", compopt[opt_indx].name);
+*/
+ Sprintf(buf, "%s\82É\89½\82ð\90Ý\92è\82·\82é\81H", compopt[opt_indx].name);
getlin(buf, buf2);
if (buf2[0] == '\033')
continue;
destroy_nhwindow(tmpwin);
if (need_redraw) {
+ check_gold_symbol();
reglyph_darkroom();
(void) doredraw();
}
return 0;
}
-int
+STATIC_OVL int
handle_add_list_remove(optname, numtotal)
const char *optname;
int numtotal;
{
winid tmpwin;
anything any;
- int i, pick_cnt, pick_idx, opt_idx;
+ int i, pick_cnt, opt_idx;
menu_item *pick_list = (menu_item *) 0;
static const struct action {
char letr;
const char *desc;
} action_titles[] = {
+#if 0 /*JP*/
{ 'a', "add new %s" }, /* [0] */
+#else
+ { 'a', "\90V\82µ\82¢%s\82ð\92Ç\89Á" }, /* [0] */
+#endif
+#if 0 /*JP*/
{ 'l', "list %s" }, /* [1] */
+#else
+ { 'l', "%s\82ð\88ê\97\97\95\\8e¦" }, /* [1] */
+#endif
+#if 0 /*JP*/
{ 'r', "remove existing %s" }, /* [2] */
+#else
+ { 'r', "\8aù\82É\82 \82é%s\82ð\8dí\8f\9c" }, /* [2] */
+#endif
+#if 0 /*JP*/
{ 'x', "exit this menu" }, /* [3] */
+#else
+ { 'x', "\82±\82Ì\83\81\83j\83\85\81[\82ð\95Â\82¶\82é" }, /* [3] */
+#endif
};
opt_idx = 0;
any = zeroany;
for (i = 0; i < SIZE(action_titles); i++) {
char tmpbuf[BUFSZ];
+
any.a_int++;
/* omit list and remove if there aren't any yet */
if (!numtotal && (i == 1 || i == 2))
Sprintf(tmpbuf, action_titles[i].desc,
(i == 1) ? makeplural(optname) : optname);
add_menu(tmpwin, NO_GLYPH, &any, action_titles[i].letr, 0, ATR_NONE,
- tmpbuf,
-#if 0 /* this ought to work but doesn't... */
- (action_titles[i].letr == 'x') ? MENU_SELECTED :
-#endif
- MENU_UNSELECTED);
+ tmpbuf, (i == 3) ? MENU_SELECTED : MENU_UNSELECTED);
}
+/*JP
end_menu(tmpwin, "Do what?");
+*/
+ end_menu(tmpwin, "\82Ç\82¤\82·\82é\81H");
if ((pick_cnt = select_menu(tmpwin, PICK_ONE, &pick_list)) > 0) {
- for (pick_idx = 0; pick_idx < pick_cnt; ++pick_idx) {
- opt_idx = pick_list[pick_idx].item.a_int - 1;
- }
+ opt_idx = pick_list[0].item.a_int - 1;
+ if (pick_cnt > 1 && opt_idx == 3)
+ opt_idx = pick_list[1].item.a_int - 1;
free((genericptr_t) pick_list);
- pick_list = (menu_item *) 0;
- }
- destroy_nhwindow(tmpwin);
-
- if (pick_cnt < 1)
+ } else
opt_idx = 3; /* none selected, exit menu */
+ destroy_nhwindow(tmpwin);
return opt_idx;
}
{
winid tmpwin;
anything any;
- int i;
+ int i, n;
char buf[BUFSZ];
/* Special handling of menustyle, pickup_burden, pickup_types,
if (!strcmp("menustyle", optname)) {
const char *style_name;
menu_item *style_pick = (menu_item *) 0;
+
tmpwin = create_nhwindow(NHW_MENU);
start_menu(tmpwin);
any = zeroany;
add_menu(tmpwin, NO_GLYPH, &any, *style_name, 0, ATR_NONE,
style_name, MENU_UNSELECTED);
}
+/*JP
end_menu(tmpwin, "Select menustyle:");
+*/
+ end_menu(tmpwin, "\83\81\83j\83\85\81[\83X\83^\83C\83\8b\82ð\91I\91ð\82µ\82Ä\82\82¾\82³\82¢\81F");
if (select_menu(tmpwin, PICK_ONE, &style_pick) > 0) {
flags.menu_style = style_pick->item.a_int - 1;
free((genericptr_t) style_pick);
add_menu(tmpwin, NO_GLYPH, &any, burden_letters[i], 0, ATR_NONE,
burden_name, MENU_UNSELECTED);
}
+/*JP
end_menu(tmpwin, "Select encumbrance level:");
+*/
+ end_menu(tmpwin, "\8cx\8d\90\82ð\8fo\82·\89×\8fd\83\8c\83x\83\8b\82ð\91I\91ð\82µ\82Ä\82\82¾\82³\82¢\81F");
if (select_menu(tmpwin, PICK_ONE, &burden_pick) > 0) {
flags.pickup_burden = burden_pick->item.a_int - 1;
free((genericptr_t) burden_pick);
};
int disc_cat[NUM_DISCLOSURE_OPTIONS];
int pick_cnt, pick_idx, opt_idx;
+ char c;
menu_item *disclosure_pick = (menu_item *) 0;
tmpwin = create_nhwindow(NHW_MENU);
ATR_NONE, buf, MENU_UNSELECTED);
disc_cat[i] = 0;
}
+/*JP
end_menu(tmpwin, "Change which disclosure options categories:");
+*/
+ end_menu(tmpwin, "\82Ç\82Ì\83J\83e\83S\83\8a\82Ì\95\\8e¦\8fî\95ñ\83I\83v\83V\83\87\83\93\82ð\95Ï\8dX\82µ\82Ü\82·\82©\81F");
pick_cnt = select_menu(tmpwin, PICK_ANY, &disclosure_pick);
if (pick_cnt > 0) {
for (pick_idx = 0; pick_idx < pick_cnt; ++pick_idx) {
for (i = 0; i < NUM_DISCLOSURE_OPTIONS; i++) {
if (disc_cat[i]) {
+ c = flags.end_disclose[i];
+/*JP
Sprintf(buf, "Disclosure options for %s:",
+*/
+ Sprintf(buf, "%s\82Ì\8fo\97Í\8c`\8e®\81F",
disclosure_names[i]);
tmpwin = create_nhwindow(NHW_MENU);
start_menu(tmpwin);
any = zeroany;
/* 'y','n',and '+' work as alternate selectors; '-' doesn't */
any.a_char = DISCLOSE_NO_WITHOUT_PROMPT;
- add_menu(tmpwin, NO_GLYPH, &any, 'a', any.a_char, ATR_NONE,
+ add_menu(tmpwin, NO_GLYPH, &any, 0, any.a_char, ATR_NONE,
+/*JP
"Never disclose, without prompting",
- MENU_UNSELECTED);
+*/
+ "\8am\94F\82¹\82¸\82É\8fo\97Í\82à\82µ\82È\82¢",
+ (c == any.a_char) ? MENU_SELECTED : MENU_UNSELECTED);
any.a_char = DISCLOSE_YES_WITHOUT_PROMPT;
- add_menu(tmpwin, NO_GLYPH, &any, 'b', any.a_char, ATR_NONE,
+ add_menu(tmpwin, NO_GLYPH, &any, 0, any.a_char, ATR_NONE,
+/*JP
"Always disclose, without prompting",
- MENU_UNSELECTED);
+*/
+ "\8am\94F\82¹\82¸\82É\8fo\97Í\82·\82é",
+ (c == any.a_char) ? MENU_SELECTED : MENU_UNSELECTED);
+ if (*disclosure_names[i] == 'v') {
+ any.a_char = DISCLOSE_SPECIAL_WITHOUT_PROMPT; /* '#' */
+ add_menu(tmpwin, NO_GLYPH, &any, 0, any.a_char, ATR_NONE,
+ "Always disclose, pick sort order from menu",
+ (c == any.a_char) ? MENU_SELECTED
+ : MENU_UNSELECTED);
+ }
any.a_char = DISCLOSE_PROMPT_DEFAULT_NO;
- add_menu(tmpwin, NO_GLYPH, &any, 'c', any.a_char, ATR_NONE,
+ add_menu(tmpwin, NO_GLYPH, &any, 0, any.a_char, ATR_NONE,
+/*JP
"Prompt, with default answer of \"No\"",
- MENU_UNSELECTED);
+*/
+ "\8am\94F\82·\82é\81C\83f\83t\83H\83\8b\83g\82Í\81u\8fo\97Í\82µ\82È\82¢\81v",
+ (c == any.a_char) ? MENU_SELECTED : MENU_UNSELECTED);
any.a_char = DISCLOSE_PROMPT_DEFAULT_YES;
- add_menu(tmpwin, NO_GLYPH, &any, 'd', any.a_char, ATR_NONE,
+ add_menu(tmpwin, NO_GLYPH, &any, 0, any.a_char, ATR_NONE,
+/*JP
"Prompt, with default answer of \"Yes\"",
- MENU_UNSELECTED);
+*/
+ "\8am\94F\82·\82é\81C\83f\83t\83H\83\8b\83g\82Í\81u\8fo\97Í\82·\82é\81v",
+ (c == any.a_char) ? MENU_SELECTED : MENU_UNSELECTED);
+ if (*disclosure_names[i] == 'v') {
+ any.a_char = DISCLOSE_PROMPT_DEFAULT_SPECIAL; /* '?' */
+ add_menu(tmpwin, NO_GLYPH, &any, 0, any.a_char, ATR_NONE,
+ "Prompt, with default answer of \"Ask\" to request sort menu",
+ (c == any.a_char) ? MENU_SELECTED
+ : MENU_UNSELECTED);
+ }
end_menu(tmpwin, buf);
- if (select_menu(tmpwin, PICK_ONE, &disclosure_pick) > 0) {
- flags.end_disclose[i] = disclosure_pick->item.a_char;
+ n = select_menu(tmpwin, PICK_ONE, &disclosure_pick);
+ if (n > 0) {
+ flags.end_disclose[i] = disclosure_pick[0].item.a_char;
+ if (n > 1 && flags.end_disclose[i] == c)
+ flags.end_disclose[i] = disclosure_pick[1].item.a_char;
free((genericptr_t) disclosure_pick);
}
destroy_nhwindow(tmpwin);
add_menu(tmpwin, NO_GLYPH, &any, *mode_name, 0, ATR_NONE,
mode_name, MENU_UNSELECTED);
}
+/*JP
end_menu(tmpwin, "Select run/travel display mode:");
+*/
+ end_menu(tmpwin, "\91\96\8ds/\83g\83\89\83x\83\8b\82Ì\95\\8e¦\83\82\81[\83h\82ð\91I\91ð\82µ\82Ä\82\82¾\82³\82¢\81F");
if (select_menu(tmpwin, PICK_ONE, &mode_pick) > 0) {
flags.runmode = mode_pick->item.a_int - 1;
free((genericptr_t) mode_pick);
}
destroy_nhwindow(tmpwin);
+ } else if (!strcmp("whatis_coord", optname)) {
+ menu_item *window_pick = (menu_item *) 0;
+ int pick_cnt;
+ char gp = iflags.getpos_coords;
+
+ tmpwin = create_nhwindow(NHW_MENU);
+ start_menu(tmpwin);
+ any = zeroany;
+ any.a_char = GPCOORDS_COMPASS;
+ add_menu(tmpwin, NO_GLYPH, &any, GPCOORDS_COMPASS,
+ 0, ATR_NONE, "compass ('east' or '3s' or '2n,4w')",
+ (gp == GPCOORDS_COMPASS) ? MENU_SELECTED : MENU_UNSELECTED);
+ any.a_char = GPCOORDS_COMFULL;
+ add_menu(tmpwin, NO_GLYPH, &any, GPCOORDS_COMFULL, 0, ATR_NONE,
+ "full compass ('east' or '3south' or '2north,4west')",
+ (gp == GPCOORDS_COMFULL) ? MENU_SELECTED : MENU_UNSELECTED);
+ any.a_char = GPCOORDS_MAP;
+ add_menu(tmpwin, NO_GLYPH, &any, GPCOORDS_MAP,
+ 0, ATR_NONE, "map <x,y>",
+ (gp == GPCOORDS_MAP) ? MENU_SELECTED : MENU_UNSELECTED);
+ any.a_char = GPCOORDS_SCREEN;
+ add_menu(tmpwin, NO_GLYPH, &any, GPCOORDS_SCREEN,
+ 0, ATR_NONE, "screen [row,column]",
+ (gp == GPCOORDS_SCREEN) ? MENU_SELECTED : MENU_UNSELECTED);
+ any.a_char = GPCOORDS_NONE;
+ add_menu(tmpwin, NO_GLYPH, &any, GPCOORDS_NONE,
+ 0, ATR_NONE, "none (no coordinates displayed)",
+ (gp == GPCOORDS_NONE) ? MENU_SELECTED : MENU_UNSELECTED);
+ any.a_long = 0L;
+ add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, "", MENU_UNSELECTED);
+ Sprintf(buf, "map: upper-left: <%d,%d>, lower-right: <%d,%d>%s",
+ 1, 0, COLNO - 1, ROWNO - 1,
+ flags.verbose ? "; column 0 unused, off left edge" : "");
+ add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, MENU_UNSELECTED);
+ if (strcmp(windowprocs.name, "tty"))
+ add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
+ "screen: row is offset to accommodate tty interface's use of top line",
+ MENU_UNSELECTED);
+#if COLNO == 80
+#define COL80ARG flags.verbose ? "; column 80 is not used" : ""
+#else
+#define COL80ARG ""
+#endif
+ Sprintf(buf, "screen: upper-left: [%02d,%02d], lower-right: [%d,%d]%s",
+ 0 + 2, 1, ROWNO - 1 + 2, COLNO - 1, COL80ARG);
+#undef COL80ARG
+ add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, MENU_UNSELECTED);
+ add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, "", MENU_UNSELECTED);
+ end_menu(tmpwin,
+ "Select coordinate display when auto-describing a map position:");
+ if ((pick_cnt = select_menu(tmpwin, PICK_ONE, &window_pick)) > 0) {
+ iflags.getpos_coords = window_pick[0].item.a_char;
+ /* PICK_ONE doesn't unselect preselected entry when
+ selecting another one */
+ if (pick_cnt > 1 && iflags.getpos_coords == gp)
+ iflags.getpos_coords = window_pick[1].item.a_char;
+ free((genericptr_t) window_pick);
+ }
+ destroy_nhwindow(tmpwin);
+ } else if (!strcmp("whatis_filter", optname)) {
+ menu_item *window_pick = (menu_item *) 0;
+ int pick_cnt;
+ char gf = iflags.getloc_filter;
+
+ tmpwin = create_nhwindow(NHW_MENU);
+ start_menu(tmpwin);
+ any = zeroany;
+ any.a_char = (GFILTER_NONE + 1);
+ add_menu(tmpwin, NO_GLYPH, &any, 'n',
+ 0, ATR_NONE, "no filtering",
+ (gf == GFILTER_NONE) ? MENU_SELECTED : MENU_UNSELECTED);
+ any.a_char = (GFILTER_VIEW + 1);
+ add_menu(tmpwin, NO_GLYPH, &any, 'v',
+ 0, ATR_NONE, "in view only",
+ (gf == GFILTER_VIEW) ? MENU_SELECTED : MENU_UNSELECTED);
+ any.a_char = (GFILTER_AREA + 1);
+ add_menu(tmpwin, NO_GLYPH, &any, 'a',
+ 0, ATR_NONE, "in same area",
+ (gf == GFILTER_AREA) ? MENU_SELECTED : MENU_UNSELECTED);
+ end_menu(tmpwin,
+ "Select location filtering when going for next/previous map position:");
+ if ((pick_cnt = select_menu(tmpwin, PICK_ONE, &window_pick)) > 0) {
+ iflags.getloc_filter = (window_pick[0].item.a_char - 1);
+ /* PICK_ONE doesn't unselect preselected entry when
+ selecting another one */
+ if (pick_cnt > 1 && iflags.getloc_filter == gf)
+ iflags.getloc_filter = (window_pick[1].item.a_char - 1);
+ free((genericptr_t) window_pick);
+ }
+ destroy_nhwindow(tmpwin);
} else if (!strcmp("msg_window", optname)) {
#ifdef TTY_GRAPHICS
/* by Christian W. Cooper */
any.a_char = 'r';
add_menu(tmpwin, NO_GLYPH, &any, 'r', 0, ATR_NONE, "reversed",
MENU_UNSELECTED);
+/*JP
end_menu(tmpwin, "Select message history display type:");
+*/
+ end_menu(tmpwin, "\83\81\83b\83Z\81[\83W\97\9a\97ð\82Ì\95\\8e¦\95û\96@\82ð\91I\91ð\82µ\82Ä\82\82¾\82³\82¢\81F");
if (select_menu(tmpwin, PICK_ONE, &window_pick) > 0) {
iflags.prevmsg_window = window_pick->item.a_char;
free((genericptr_t) window_pick);
sortl_name = sortltype[i];
any.a_char = *sortl_name;
add_menu(tmpwin, NO_GLYPH, &any, *sortl_name, 0, ATR_NONE,
- sortl_name, MENU_UNSELECTED);
+ sortl_name, (flags.sortloot == *sortl_name)
+ ? MENU_SELECTED : MENU_UNSELECTED);
}
end_menu(tmpwin, "Select loot sorting type:");
- if (select_menu(tmpwin, PICK_ONE, &sortl_pick) > 0) {
- flags.sortloot = sortl_pick->item.a_char;
+ n = select_menu(tmpwin, PICK_ONE, &sortl_pick);
+ if (n > 0) {
+ char c = sortl_pick[0].item.a_char;
+
+ if (n > 1 && c == flags.sortloot)
+ c = sortl_pick[1].item.a_char;
+ flags.sortloot = c;
free((genericptr_t) sortl_pick);
}
destroy_nhwindow(tmpwin);
any.a_int = ALIGN_RIGHT;
add_menu(tmpwin, NO_GLYPH, &any, 'r', 0, ATR_NONE, "right",
MENU_UNSELECTED);
+#if 0 /*JP*/
Sprintf(abuf, "Select %s window placement relative to the map:",
msg ? "message" : "status");
+#else
+ Sprintf(abuf, "%s\83E\83B\83\93\83h\83E\82Ì\83}\83b\83v\82É\91Î\82·\82é\95\\8e¦\88Ê\92u\82ð\91I\91ð\82µ\82Ä\82\82¾\82³\82¢\81F",
+ msg ? "\83\81\83b\83Z\81[\83W" : "\8fó\91Ô");
+#endif
end_menu(tmpwin, abuf);
if (select_menu(tmpwin, PICK_ONE, &window_pick) > 0) {
if (msg)
destroy_nhwindow(tmpwin);
} else if (!strcmp("number_pad", optname)) {
static const char *npchoices[] = {
+/*JP
" 0 (off)", " 1 (on)", " 2 (on, MSDOS compatible)",
+*/
+ "0 (\96³\8cø)", "1 (\97L\8cø)", "2 (\97L\8cø\81CMSDOS\8cÝ\8a·)",
+/*JP
" 3 (on, phone-style digit layout)",
+*/
+ " 3 (\97L\8cø\81C\93d\98b\8e®\82Ì\90\94\8e\9a\94z\92u)",
+/*JP
" 4 (on, phone-style layout, MSDOS compatible)",
+*/
+ " 4 (\97L\8cø\81C\93d\98b\8e®\82Ì\94z\92u\81CMSDOS \8cÝ\8a·)",
+/*JP
"-1 (off, 'z' to move upper-left, 'y' to zap wands)"
+*/
+ "-1 (\96³\8cø\81C'z' \82Å\8d¶\8fã\82É\88Ú\93®\81C'y' \82Å\8fñ\82ð\90U\82é)"
};
menu_item *mode_pick = (menu_item *) 0;
add_menu(tmpwin, NO_GLYPH, &any, 'a' + i, 0, ATR_NONE,
npchoices[i], MENU_UNSELECTED);
}
+/*JP
end_menu(tmpwin, "Select number_pad mode:");
+*/
+ end_menu(tmpwin, "number_pad\83\82\81[\83h\82ð\91I\91ð\82µ\82Ä\82\82¾\82³\82¢\81F");
if (select_menu(tmpwin, PICK_ONE, &mode_pick) > 0) {
switch (mode_pick->item.a_int - 1) {
case 0:
}
destroy_nhwindow(tmpwin);
} else if (!strcmp("menu_headings", optname)) {
+/*JP
int mhattr = query_attr("How to highlight menu headings:");
+*/
+ int mhattr = query_attr("\83\81\83j\83\85\81[\83w\83b\83_\82Ì\8b\92²\95û\96@\82ð\91I\91ð\82µ\82Ä\82\82¾\82³\82¢\81F");
if (mhattr != -1)
iflags.menu_headings = mhattr;
} else if (!strcmp("msgtype", optname)) {
int opt_idx, nmt, mttyp;
- char mtbuf[BUFSZ];
+ char mtbuf[BUFSZ] = DUMMY;
msgtypes_again:
nmt = msgtype_count();
opt_idx = handle_add_list_remove("message type", nmt);
- if (opt_idx == 3) {
- ; /* done--fall through to function exit */
+ if (opt_idx == 3) { /* done */
+ return TRUE;
} else if (opt_idx == 0) { /* add new */
getlin("What new message pattern?", mtbuf);
- if (*mtbuf == '\033' || !*mtbuf)
- goto msgtypes_again;
- mttyp = query_msgtype();
- if (mttyp == -1)
- goto msgtypes_again;
- if (!msgtype_add(mttyp, mtbuf)) {
+ if (*mtbuf == '\033')
+ return TRUE;
+ if (*mtbuf
+ && test_regex_pattern(mtbuf, (const char *)0)
+ && (mttyp = query_msgtype()) != -1
+ && !msgtype_add(mttyp, mtbuf)) {
pline("Error adding the message type.");
wait_synch();
- goto msgtypes_again;
}
- } else { /* list or remove */
+ goto msgtypes_again;
+ } else { /* list (1) or remove (2) */
int pick_idx, pick_cnt;
int mt_idx;
+ unsigned ln;
+ const char *mtype;
menu_item *pick_list = (menu_item *) 0;
struct plinemsg_type *tmp = plinemsg_types;
any = zeroany;
mt_idx = 0;
while (tmp) {
- const char *mtype = msgtype2name(tmp->msgtype);
-
+ mtype = msgtype2name(tmp->msgtype);
any.a_int = ++mt_idx;
- Sprintf(mtbuf, "%-5s \"%s\"", mtype, tmp->pattern);
+ Sprintf(mtbuf, "%-5s \"", mtype);
+ ln = sizeof mtbuf - strlen(mtbuf) - sizeof "\"";
+ if (strlen(tmp->pattern) > ln)
+ Strcat(strncat(mtbuf, tmp->pattern, ln - 3), "...\"");
+ else
+ Strcat(mtbuf, "\"");
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, mtbuf,
MENU_UNSELECTED);
tmp = tmp->next;
}
} else if (!strcmp("menucolors", optname)) {
int opt_idx, nmc, mcclr, mcattr;
- char mcbuf[BUFSZ];
+ char mcbuf[BUFSZ] = DUMMY;
menucolors_again:
nmc = count_menucolors();
opt_idx = handle_add_list_remove("menucolor", nmc);
- if (opt_idx == 3) {
- ; /* done--fall through to function exit */
+ if (opt_idx == 3) { /* done */
+ return TRUE;
} else if (opt_idx == 0) { /* add new */
getlin("What new menucolor pattern?", mcbuf);
- if (*mcbuf == '\033' || !*mcbuf)
- goto menucolors_again;
- mcclr = query_color();
- if (mcclr == -1)
- goto menucolors_again;
- mcattr = query_attr(NULL);
- if (mcattr == -1)
- goto menucolors_again;
- if (!add_menu_coloring_parsed(mcbuf, mcclr, mcattr)) {
+ if (*mcbuf == '\033')
+ return TRUE;
+ if (*mcbuf
+ && test_regex_pattern(mcbuf, (const char *)0)
+ && (mcclr = query_color((char *) 0)) != -1
+ && (mcattr = query_attr((char *) 0)) != -1
+ && !add_menu_coloring_parsed(mcbuf, mcclr, mcattr)) {
pline("Error adding the menu color.");
wait_synch();
- goto menucolors_again;
}
- } else { /* list or remove */
+ goto menucolors_again;
+ } else { /* list (1) or remove (2) */
int pick_idx, pick_cnt;
int mc_idx;
+ unsigned ln;
+ const char *sattr, *sclr;
menu_item *pick_list = (menu_item *) 0;
struct menucoloring *tmp = menu_colorings;
any = zeroany;
mc_idx = 0;
while (tmp) {
- const char *sattr = attr2attrname(tmp->attr);
- const char *sclr = clr2colorname(tmp->color);
-
- any.a_int = (++mc_idx);
- Sprintf(mcbuf, "\"%s\"=%s%s%s", tmp->origstr, sclr,
+ sattr = attr2attrname(tmp->attr);
+ sclr = clr2colorname(tmp->color);
+ any.a_int = ++mc_idx;
+ /* construct suffix */
+ Sprintf(buf, "\"\"=%s%s%s", sclr,
(tmp->attr != ATR_NONE) ? " & " : "",
(tmp->attr != ATR_NONE) ? sattr : "");
+ /* now main string */
+ ln = sizeof buf - strlen(buf) - 1; /* length available */
+ Strcpy(mcbuf, "\"");
+ if (strlen(tmp->origstr) > ln)
+ Strcat(strncat(mcbuf, tmp->origstr, ln - 3), "...");
+ else
+ Strcat(mcbuf, tmp->origstr);
+ /* combine main string and suffix */
+ Strcat(mcbuf, &buf[1]); /* skip buf[]'s initial quote */
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, mcbuf,
MENU_UNSELECTED);
tmp = tmp->next;
}
} else if (!strcmp("autopickup_exception", optname)) {
int opt_idx, pass, totalapes = 0, numapes[2] = { 0, 0 };
- char apebuf[1 + BUFSZ]; /* so &apebuf[1] is BUFSZ long for getlin() */
+ char apebuf[1 + BUFSZ] = DUMMY; /* so &apebuf[1] is BUFSZ long for getlin() */
struct autopickup_exception *ape;
ape_again:
totalapes = count_ape_maps(&numapes[AP_LEAVE], &numapes[AP_GRAB]);
opt_idx = handle_add_list_remove("autopickup exception", totalapes);
- if (opt_idx == 3) {
- ; /* done--fall through to function exit */
+ if (opt_idx == 3) { /* done */
+ return TRUE;
} else if (opt_idx == 0) { /* add new */
+/*JP
getlin("What new autopickup exception pattern?", &apebuf[1]);
+*/
+ getlin("\90V\82µ\82¢\8e©\93®\8fE\82¢\97á\8aO\82Ì\83p\83^\81[\83\93\82ð\93ü\97Í\82µ\82Ä\82\82¾\82³\82¢\81F", &apebuf[1]);
mungspaces(&apebuf[1]); /* regularize whitespace */
- if (apebuf[1] == '\033') {
- ; /* fall through to function exit */
- } else {
- if (apebuf[1]) {
- apebuf[0] = '\"';
- /* guarantee room for \" prefix and \"\0 suffix;
- -2 is good enough for apebuf[] but -3 makes
- sure the whole thing fits within normal BUFSZ */
- apebuf[sizeof apebuf - 3] = '\0';
- Strcat(apebuf, "\"");
- add_autopickup_exception(apebuf);
- }
- goto ape_again;
+ if (apebuf[1] == '\033')
+ return TRUE;
+ if (apebuf[1]) {
+ apebuf[0] = '\"';
+ /* guarantee room for \" prefix and \"\0 suffix;
+ -2 is good enough for apebuf[] but -3 makes
+ sure the whole thing fits within normal BUFSZ */
+ apebuf[sizeof apebuf - 3] = '\0';
+ Strcat(apebuf, "\"");
+ add_autopickup_exception(apebuf);
}
- } else { /* list or remove */
+ goto ape_again;
+ } else { /* list (1) or remove (2) */
int pick_idx, pick_cnt;
menu_item *pick_list = (menu_item *) 0;
ape = iflags.autopickup_exceptions[pass];
any = zeroany;
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, iflags.menu_headings,
+/*JP
(pass == 0) ? "Never pickup" : "Always pickup",
+*/
+ (pass == 0) ? "\8fí\82É\8fE\82í\82È\82¢" : "\8fí\82É\8fE\82¤",
MENU_UNSELECTED);
for (i = 0; i < numapes[pass] && ape; i++) {
any.a_void = (opt_idx == 1) ? 0 : ape;
+ /* length of pattern plus quotes is less than BUFSZ */
Sprintf(apebuf, "\"%s\"", ape->pattern);
add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, apebuf,
MENU_UNSELECTED);
ape = ape->next;
}
}
+#if 0 /*JP*/
Sprintf(apebuf, "%s autopickup exceptions",
(opt_idx == 1) ? "List of" : "Remove which");
+#else
+ Sprintf(apebuf, "%s\8e©\93®\8fE\82¢\97á\8aO%s",
+ (opt_idx == 1) ? "" : "\82Ç\82Ì",
+ (opt_idx == 1) ? "\82Ì\88ê\97\97" : "\82ð\8dí\8f\9c\82µ\82Ü\82·\82©\81H");
+#endif
end_menu(tmpwin, apebuf);
pick_cnt = select_menu(tmpwin,
(opt_idx == 1) ? PICK_NONE : PICK_ANY,
struct symsetentry *sl;
int res, which_set, setcount = 0, chosen = -2;
- if (rogueflag)
- which_set = ROGUESET;
- else
- which_set = PRIMARY;
+ which_set = rogueflag ? ROGUESET : PRIMARY;
/* clear symset[].name as a flag to read_sym_file() to build list */
symset_name = symset[which_set].name;
}
sl = sl->next;
}
- end_menu(tmpwin, "Select symbol set:");
+ Sprintf(buf, "Select %ssymbol set:",
+ rogueflag ? "rogue level " : "");
+ end_menu(tmpwin, buf);
if (select_menu(tmpwin, PICK_ONE, &symset_pick) > 0) {
chosen = symset_pick->item.a_int - 2;
free((genericptr_t) symset_pick);
assign_graphics(ROGUESET);
} else if (!rogueflag)
assign_graphics(PRIMARY);
+ preference_update("symset");
need_redraw = TRUE;
return TRUE;
char *buf;
{
char ocl[MAXOCLASSES + 1];
+#if 0 /*JP*/
static const char none[] = "(none)", randomrole[] = "random",
to_be_done[] = "(to be done)", defopt[] = "default",
defbrief[] = "def";
+#else
+ static const char none[] = "(\82È\82µ)", randomrole[] = "\83\89\83\93\83_\83\80",
+ to_be_done[] = "(\96¢\90Ý\92è)", defopt[] = "\83f\83t\83H\83\8b\83g",
+ defbrief[] = "def";
+#endif
int i;
buf[0] = '\0';
if (!strcmp(optname, "align_message"))
+#if 0 /*JP*/
Sprintf(buf, "%s",
iflags.wc_align_message == ALIGN_TOP
? "top"
: iflags.wc_align_message == ALIGN_RIGHT
? "right"
: defopt);
+#else
+ Sprintf(buf, "%s",
+ iflags.wc_align_message == ALIGN_TOP
+ ? "\8fã\91¤"
+ : iflags.wc_align_message == ALIGN_LEFT
+ ? "\8d¶\91¤"
+ : iflags.wc_align_message == ALIGN_BOTTOM
+ ? "\89º\91¤"
+ : iflags.wc_align_message == ALIGN_RIGHT
+ ? "\89E\91¤" : defopt);
+#endif
else if (!strcmp(optname, "align_status"))
+#if 0 /*JP*/
Sprintf(buf, "%s",
iflags.wc_align_status == ALIGN_TOP
? "top"
: iflags.wc_align_status == ALIGN_RIGHT
? "right"
: defopt);
+#else
+ Sprintf(buf, "%s",
+ iflags.wc_align_status == ALIGN_TOP
+ ? "\8fã\91¤"
+ : iflags.wc_align_status == ALIGN_LEFT
+ ? "\8d¶\91¤"
+ : iflags.wc_align_status == ALIGN_BOTTOM
+ ? "\89º\91¤"
+ : iflags.wc_align_status == ALIGN_RIGHT
+ ? "\89E\91¤"
+ : defopt);
+#endif
else if (!strcmp(optname, "align"))
Sprintf(buf, "%s", rolestring(flags.initalign, aligns, adj));
#ifdef WIN32
else if (!strcmp(optname, "altkeyhandler"))
Sprintf(buf, "%s",
+/*JP
iflags.altkeyhandler[0] ? iflags.altkeyhandler : "default");
+*/
+ iflags.altkeyhandler[0] ? iflags.altkeyhandler : defopt);
#endif
#ifdef BACKWARD_COMPAT
else if (!strcmp(optname, "boulder"))
Sprintf(buf, "%s", rolestring(flags.initgend, genders, adj));
else if (!strcmp(optname, "horsename"))
Sprintf(buf, "%s", horsename[0] ? horsename : none);
- else if (!strcmp(optname, "map_mode"))
+ else if (!strcmp(optname, "map_mode")) {
+ i = iflags.wc_map_mode;
Sprintf(buf, "%s",
- iflags.wc_map_mode == MAP_MODE_TILES
- ? "tiles"
- : iflags.wc_map_mode == MAP_MODE_ASCII4x6
- ? "ascii4x6"
- : iflags.wc_map_mode == MAP_MODE_ASCII6x8
- ? "ascii6x8"
- : iflags.wc_map_mode == MAP_MODE_ASCII8x8
- ? "ascii8x8"
- : iflags.wc_map_mode == MAP_MODE_ASCII16x8
- ? "ascii16x8"
- : iflags.wc_map_mode == MAP_MODE_ASCII7x12
- ? "ascii7x12"
- : iflags.wc_map_mode == MAP_MODE_ASCII8x12
- ? "ascii8x12"
- : iflags.wc_map_mode
- == MAP_MODE_ASCII16x12
- ? "ascii16x12"
- : iflags.wc_map_mode
- == MAP_MODE_ASCII12x16
- ? "ascii12x16"
- : iflags.wc_map_mode
- == MAP_MODE_ASCII10x18
- ? "ascii10x18"
- : iflags.wc_map_mode
- == MAP_MODE_ASCII_FIT_TO_SCREEN
- ? "fit_to_screen"
- : defopt);
- else if (!strcmp(optname, "menustyle"))
+ (i == MAP_MODE_TILES) ? "tiles"
+ : (i == MAP_MODE_ASCII4x6) ? "ascii4x6"
+ : (i == MAP_MODE_ASCII6x8) ? "ascii6x8"
+ : (i == MAP_MODE_ASCII8x8) ? "ascii8x8"
+ : (i == MAP_MODE_ASCII16x8) ? "ascii16x8"
+ : (i == MAP_MODE_ASCII7x12) ? "ascii7x12"
+ : (i == MAP_MODE_ASCII8x12) ? "ascii8x12"
+ : (i == MAP_MODE_ASCII16x12) ? "ascii16x12"
+ : (i == MAP_MODE_ASCII12x16) ? "ascii12x16"
+ : (i == MAP_MODE_ASCII10x18) ? "ascii10x18"
+ : (i == MAP_MODE_ASCII_FIT_TO_SCREEN)
+ ? "fit_to_screen"
+ : defopt);
+ } else if (!strcmp(optname, "menustyle"))
Sprintf(buf, "%s", menutype[(int) flags.menu_style]);
else if (!strcmp(optname, "menu_deselect_all"))
Sprintf(buf, "%s", to_be_done);
Sprintf(buf, "%u", iflags.msg_history);
#ifdef TTY_GRAPHICS
} else if (!strcmp(optname, "msg_window")) {
- Sprintf(buf, "%s", (iflags.prevmsg_window == 's')
- ? "single"
- : (iflags.prevmsg_window == 'c')
- ? "combination"
- : (iflags.prevmsg_window == 'f')
- ? "full"
- : "reversed");
+ Sprintf(buf, "%s", (iflags.prevmsg_window == 's') ? "single"
+ : (iflags.prevmsg_window == 'c') ? "combination"
+ : (iflags.prevmsg_window == 'f') ? "full"
+ : "reversed");
#endif
} else if (!strcmp(optname, "name")) {
Sprintf(buf, "%s", plname);
} else if (!strcmp(optname, "number_pad")) {
static const char *numpadmodes[] = {
+/*JP
"0=off", "1=on", "2=on, MSDOS compatible",
+*/
+ "0=\96³\8cø", "1=\97L\8cø", "2=\97L\8cø\81CDOS\8cÝ\8a·",
+/*JP
"3=on, phone-style layout",
+*/
+ "3=\97L\8cø\81C\93d\98b\8e®\82Ì\90\94\8e\9a\94z\92u",
+/*JP
"4=on, phone layout, MSDOS compatible",
+*/
+ "4=\97L\8cø\81C\93d\98b\8e®\82Ì\94z\92u\81CMSDOS \8cÝ\8a·",
+#if 0 /*JP*/
"-1=off, y & z swapped", /*[5]*/
+#else
+ "-1=\96³\8cø\81Cy\82Æz\82ð\93ü\82ê\91Ö\82¦", /*[5]*/
+#endif
};
int indx = Cmd.num_pad
? (Cmd.phone_layout ? (Cmd.pcHack_compat ? 4 : 3)
char tmpbuf[QBUFSZ];
tmpbuf[0] = '\0';
- if (ParanoidConfirm)
- Strcat(tmpbuf, " Confirm");
- if (ParanoidQuit)
- Strcat(tmpbuf, " quit");
- if (ParanoidDie)
- Strcat(tmpbuf, " die");
- if (ParanoidBones)
- Strcat(tmpbuf, " bones");
- if (ParanoidHit)
- Strcat(tmpbuf, " attack");
- if (ParanoidPray)
- Strcat(tmpbuf, " pray");
- if (ParanoidRemove)
- Strcat(tmpbuf, " Remove");
+ for (i = 0; paranoia[i].flagmask != 0; ++i)
+ if (flags.paranoia_bits & paranoia[i].flagmask)
+ Sprintf(eos(tmpbuf), " %s", paranoia[i].argname);
Strcpy(buf, tmpbuf[0] ? &tmpbuf[1] : "none");
} else if (!strcmp(optname, "pettype")) {
+#if 0 /*JP*/
Sprintf(buf, "%s", (preferred_pet == 'c') ? "cat"
: (preferred_pet == 'd') ? "dog"
: (preferred_pet == 'h') ? "horse"
: (preferred_pet == 'n') ? "none"
: "random");
+#else
+ Sprintf(buf, "%s", (preferred_pet == 'c') ? "\94L"
+ : (preferred_pet == 'd') ? "\8c¢"
+ : (preferred_pet == 'h') ? "\94n"
+ : (preferred_pet == 'n') ? "\82È\82µ"
+ : "\83\89\83\93\83_\83\80");
+#endif
} else if (!strcmp(optname, "pickup_burden")) {
Sprintf(buf, "%s", burdentype[flags.pickup_burden]);
} else if (!strcmp(optname, "pickup_types")) {
Sprintf(buf, "%s", rolestring(flags.initrole, roles, name.m));
} else if (!strcmp(optname, "runmode")) {
Sprintf(buf, "%s", runmodes[flags.runmode]);
+ } else if (!strcmp(optname, "whatis_coord")) {
+ Sprintf(buf, "%s",
+ (iflags.getpos_coords == GPCOORDS_MAP) ? "map"
+ : (iflags.getpos_coords == GPCOORDS_COMPASS) ? "compass"
+ : (iflags.getpos_coords == GPCOORDS_COMFULL) ? "full compass"
+ : (iflags.getpos_coords == GPCOORDS_SCREEN) ? "screen"
+ : "none");
+ } else if (!strcmp(optname, "whatis_filter")) {
+ Sprintf(buf, "%s",
+ (iflags.getloc_filter == GFILTER_VIEW) ? "view"
+ : (iflags.getloc_filter == GFILTER_AREA) ? "area"
+ : "none");
} else if (!strcmp(optname, "scores")) {
Sprintf(buf, "%d top/%d around%s", flags.end_top, flags.end_around,
flags.end_own ? "/own" : "");
break;
}
} else if (!strcmp(optname, "player_selection")) {
+#if 0 /*JP*/
Sprintf(buf, "%s", iflags.wc_player_selection ? "prompts" : "dialog");
+#else
+ Sprintf(buf, "%s\93ü\97Í", iflags.wc_player_selection ? "\83v\83\8d\83\93\83v\83g" : "\83_\83C\83A\83\8d\83O");
+#endif
#ifdef MSDOS
} else if (!strcmp(optname, "soundcard")) {
Sprintf(buf, "%s", to_be_done);
#endif
+#ifdef STATUS_HILITES
+ } else if (!strcmp("statushilites", optname)) {
+ if (!iflags.hilite_delta)
+ Strcpy(buf, "0 (off: don't highlight status fields)");
+ else
+ Sprintf(buf, "%ld (on: highlight status for %ld turns)",
+ iflags.hilite_delta, iflags.hilite_delta);
+#endif
} else if (!strcmp(optname, "suppress_alert")) {
if (flags.suppress_alert == 0L)
Strcpy(buf, none);
if (buf[0])
return buf;
else
+/*JP
return "unknown";
+*/
+ return "\95s\96¾";
}
int
flags.pickup = !flags.pickup;
if (flags.pickup) {
oc_to_str(flags.pickup_types, ocl);
+#if 0 /*JP*/
Sprintf(buf, "ON, for %s objects%s", ocl[0] ? ocl : "all",
(iflags.autopickup_exceptions[AP_LEAVE]
|| iflags.autopickup_exceptions[AP_GRAB])
? ", with one exception"
: ", with some exceptions")
: "");
+#else
+ Sprintf(buf, "%s\83A\83C\83e\83\80\82É\82Â\82¢\82Ä\83I\83\93%s", ocl[0] ? ocl : "\91S\82Ä\82Ì",
+ (iflags.autopickup_exceptions[AP_LEAVE]
+ || iflags.autopickup_exceptions[AP_GRAB])
+ ? "\81C\97á\8aO\82 \82è"
+ : "");
+#endif
} else {
+/*JP
Strcpy(buf, "OFF");
+*/
+ Strcpy(buf, "\83I\83t");
}
+/*JP
pline("Autopickup: %s.", buf);
+*/
+ pline("\8e©\93®\8fE\82¢\81F%s\81D", buf);
return 0;
}
add_autopickup_exception(mapping)
const char *mapping;
{
+ static const char
+ APE_regex_error[] = "regex error in AUTOPICKUP_EXCEPTION",
+ APE_syntax_error[] = "syntax error in AUTOPICKUP_EXCEPTION";
+
struct autopickup_exception *ape, **apehead;
- char text[256], *text2;
+ char text[256], end;
+ int n;
boolean grab = FALSE;
- if (sscanf(mapping, "\"%255[^\"]\"", text) == 1) {
- text2 = &text[0];
- if (*text2 == '<') { /* force autopickup */
- grab = TRUE;
- ++text2;
- } else if (*text2 == '>') { /* default - Do not pickup */
- grab = FALSE;
- ++text2;
- }
- apehead = (grab) ? &iflags.autopickup_exceptions[AP_GRAB]
- : &iflags.autopickup_exceptions[AP_LEAVE];
- ape = (struct autopickup_exception *) alloc(
- sizeof (struct autopickup_exception));
- ape->regex = regex_init();
- if (!regex_compile(text2, ape->regex)) {
- raw_print("regex error in AUTOPICKUP_EXCEPTION");
- regex_free(ape->regex);
- free((genericptr_t) ape);
- return 0;
- }
- ape->pattern = (char *) alloc(strlen(text2) + 1);
- strcpy(ape->pattern, text2);
- ape->grab = grab;
- ape->next = *apehead;
- *apehead = ape;
+ /* scan length limit used to be 255, but smaller size allows the
+ quoted value to fit within BUFSZ, simplifying formatting elsewhere;
+ this used to ignore the possibility of trailing junk but now checks
+ for it, accepting whitespace but rejecting anything else unless it
+ starts with '#" for a comment */
+ end = '\0';
+ if ((n = sscanf(mapping, "\"<%253[^\"]\" %c", text, &end)) == 1
+ || (n == 2 && end == '#')) {
+ grab = TRUE;
+ } else if ((n = sscanf(mapping, "\">%253[^\"]\" %c", text, &end)) == 1
+ || (n = sscanf(mapping, "\"%253[^\"]\" %c", text, &end)) == 1
+ || (n == 2 && end == '#')) {
+ grab = FALSE;
} else {
- raw_print("syntax error in AUTOPICKUP_EXCEPTION");
+ config_error_add("%s", APE_syntax_error);
+ return 0;
+ }
+
+ ape = (struct autopickup_exception *) alloc(sizeof *ape);
+ ape->regex = regex_init();
+ if (!regex_compile(text, ape->regex)) {
+ config_error_add("%s: %s", APE_regex_error,
+ regex_error_desc(ape->regex));
+ regex_free(ape->regex);
+ free((genericptr_t) ape);
return 0;
}
+ apehead = (grab) ? &iflags.autopickup_exceptions[AP_GRAB]
+ : &iflags.autopickup_exceptions[AP_LEAVE];
+
+ ape->pattern = dupstr(text);
+ ape->grab = grab;
+ ape->next = *apehead;
+ *apehead = ape;
return 1;
}
int *leave, *grab;
{
struct autopickup_exception *ape;
- int pass, totalapes, numapes[2] = { 0, 0 };
+ int pass, totalapes, numapes[2];
+ numapes[0] = numapes[1] = 0;
for (pass = AP_LEAVE; pass <= AP_GRAB; ++pass) {
ape = iflags.autopickup_exceptions[pass];
while (ape) {
}
/* Parse the value of a SYMBOLS line from a config file */
-void
+boolean
parsesymbols(opts)
register char *opts;
{
if ((op = index(opts, ',')) != 0) {
*op++ = 0;
- parsesymbols(op);
+ if (!parsesymbols(op))
+ return FALSE;
}
/* S_sample:string */
if (!strval)
strval = index(opts, '=');
if (!strval)
- return;
+ return FALSE;
*strval++ = '\0';
/* strip leading and trailing white space from symname and strval */
symp = match_sym(symname);
if (!symp)
- return;
+ return FALSE;
if (symp->range && symp->range != SYM_CONTROL) {
val = sym_val(strval);
update_l_symset(symp, val);
}
+ return TRUE;
}
struct symparse *
int
sym_val(strval)
-char *strval;
+const char *strval;
{
char buf[QBUFSZ];
+
buf[0] = '\0';
- escapes(strval, buf);
+ if (!strval[0] || !strval[1]) { /* empty, or single character */
+ /* if single char is space or tab, leave buf[0]=='\0' */
+ if (!isspace((uchar) strval[0]))
+ buf[0] = strval[0];
+ } else if (strval[0] == '\'') { /* single quote */
+ /* simple matching single quote; we know strval[1] isn't '\0' */
+ if (strval[2] == '\'' && !strval[3]) {
+ /* accepts '\' as backslash and ''' as single quote */
+ buf[0] = strval[1];
+
+ /* if backslash, handle single or double quote or second backslash */
+ } else if (strval[1] == '\\' && strval[2] && strval[3] == '\''
+ && index("'\"\\", strval[2]) && !strval[4]) {
+ buf[0] = strval[2];
+
+ /* not simple quote or basic backslash;
+ strip closing quote and let escapes() deal with it */
+ } else {
+ char *p, tmp[QBUFSZ];
+
+ (void) strncpy(tmp, strval + 1, sizeof tmp - 1);
+ tmp[sizeof tmp - 1] = '\0';
+ if ((p = rindex(tmp, '\'')) != 0) {
+ *p = '\0';
+ escapes(tmp, buf);
+ } /* else buf[0] stays '\0' */
+ }
+ } else /* not lone char nor single quote */
+ escapes(strval, buf);
+
return (int) *buf;
}
/* data for option_help() */
static const char *opt_intro[] = {
+/*JP
"", " NetHack Options Help:", "",
+*/
+ "", " NetHack\83I\83v\83V\83\87\83\93\83w\83\8b\83v\81F", "",
#define CONFIG_SLOT 3 /* fill in next value at run-time */
(char *) 0,
#if !defined(MICRO) && !defined(MAC)
+/*JP
"or use `NETHACKOPTIONS=\"<options>\"' in your environment",
+*/
+ "\82Ü\82½\82Í\8aÂ\8b«\95Ï\90\94\82É`NETHACKOPTIONS=\"<options>\"'\82Æ\92è\8b`\82Å\82«\82Ü\82·",
#endif
+/*JP
"(<options> is a list of options separated by commas)",
+*/
+ "(<options>\82Í\83J\83\93\83}\82Å\8bæ\90Ø\82Á\82½\83I\83v\83V\83\87\83\93\82Å\82·)",
#ifdef VMS
+/*JP
"-- for example, $ DEFINE NETHACKOPTIONS \"noautopickup,fruit:kumquat\"",
+*/
+ "-- \97á\82¦\82Î\8e\9f\82Ì\82æ\82¤\82É\82µ\82Ü\82·\81F$ DEFINE NETHACKOPTIONS \"noautopickup,fruit:kumquat\"",
#endif
+/*JP
"or press \"O\" while playing and use the menu.", "",
+*/
+ "\82à\82µ\82\82Í\83Q\81[\83\80\83v\83\8c\83C\92\86\82É\"O\"\83{\83^\83\93\82ð\89\9f\82·\82±\82Æ\82Å\90Ý\92è\89Â\94\\82Å\82·\81D",
+/*JP
"Boolean options (which can be negated by prefixing them with '!' or \"no\"):",
+*/
+ "\90^\8bU\92l\83I\83v\83V\83\87\83\93 (\94Û\92è\82Ì\92l\82ð\8ew\92è\82·\82é\8fê\8d\87\81C'!'\82à\82µ\82\82Í\"no\"\82ð\90æ\93ª\82É\95t\89Á\82µ\82Ü\82·):",
(char *) 0
};
static const char *opt_epilog[] = {
"",
+/*JP
"Some of the options can be set only before the game is started; those",
+*/
+ "\83I\83v\83V\83\87\83\93\82É\82Í\83Q\81[\83\80\8aJ\8en\91O\82Ì\82Ý\82É\82µ\82©\90Ý\92è\82Å\82«\82È\82¢\82à\82Ì\82ª\82 \82è\82Ü\82·\81D",
+/*JP
"items will not be selectable in the 'O' command's menu.", (char *) 0
+*/
+ "\82»\82ê\82ç\82Í'O'\83R\83}\83\93\83h\82Ì\83\81\83j\83\85\81[\82Å\82Í\91I\91ð\82·\82é\82±\82Æ\82ª\82Å\82«\82Ü\82¹\82ñ\81D", (char *) 0
};
void
winid datawin;
datawin = create_nhwindow(NHW_TEXT);
- Sprintf(buf, "Set options as OPTIONS=<options> in %s", lastconfigfile);
+/*JP
+ Sprintf(buf, "Set options as OPTIONS=<options> in %s", configfile);
+*/
+ Sprintf(buf, "\83I\83v\83V\83\87\83\93\82Í%s\82Ì\92\86\82ÅOPTIONS=<options>\82Æ\90Ý\92è\82µ\82Ü\82·", configfile);
opt_intro[CONFIG_SLOT] = (const char *) buf;
for (i = 0; opt_intro[i]; i++)
putstr(datawin, 0, opt_intro[i]);
next_opt(datawin, "");
/* Compound options */
+/*JP
putstr(datawin, 0, "Compound options:");
+*/
+ putstr(datawin, 0, "\95¶\8e\9a\97ñ\83I\83v\83V\83\87\83\93:");
for (i = 0; compopt[i].name; i++) {
Sprintf(buf2, "`%s'", compopt[i].name);
Sprintf(buf, "%-20s - %s%c", buf2, compopt[i].descr,
/* disallow naming after other foods (since it'd be impossible
* to tell the difference)
*/
-
for (i = bases[FOOD_CLASS]; objects[i].oc_class == FOOD_CLASS; i++) {
if (!strcmp(OBJ_NAME(objects[i]), pl_fruit)) {
found = TRUE;
{
char *c;
- c = pl_fruit;
-
for (c = pl_fruit; *c >= '0' && *c <= '9'; c++)
- ;
+ continue;
if (isspace((uchar) *c) || *c == 0)
numeric = TRUE;
}
- if (found || numeric || !strncmp(str, "cursed ", 7)
- || !strncmp(str, "uncursed ", 9) || !strncmp(str, "blessed ", 8)
+ if (found || numeric
+ || !strncmp(str, "cursed ", 7)
+ || !strncmp(str, "uncursed ", 9)
+ || !strncmp(str, "blessed ", 8)
|| !strncmp(str, "partly eaten ", 13)
|| (!strncmp(str, "tin of ", 7)
&& (!strcmp(str + 7, "spinach")
*/
flags.made_fruit = FALSE;
if (replace_fruit) {
- for (f = ffruit; f; f = f->nextf) {
- if (f == replace_fruit) {
- copynchars(f->fname, str, PL_FSIZ - 1);
- goto nonew;
- }
- }
+ /* replace_fruit is already part of the fruit chain;
+ update it in place rather than looking it up again */
+ f = replace_fruit;
+ copynchars(f->fname, str, PL_FSIZ - 1);
+ goto nonew;
}
} else {
/* not user_supplied, so assumed to be from bones */
copynchars(altname, str, PL_FSIZ - 1);
sanitize_name(altname);
flags.made_fruit = TRUE; /* for safety. Any fruit name added from a
- bones level should exist anyway. */
+ * bones level should exist anyway. */
}
- for (f = ffruit; f; f = f->nextf) {
- if (f->fid > highest_fruit_id)
- highest_fruit_id = f->fid;
- if (!strncmp(str, f->fname, PL_FSIZ - 1)
- || (*altname && !strcmp(altname, f->fname)))
- goto nonew;
- }
- /* if adding another fruit would overflow spe, use a random
- fruit instead... we've got a lot to choose from.
+ f = fruit_from_name(*altname ? altname : str, FALSE, &highest_fruit_id);
+ if (f)
+ goto nonew;
+
+ /* Maximum number of named fruits is 127, even if obj->spe can
+ handle bigger values. If adding another fruit would overflow,
+ use a random fruit instead... we've got a lot to choose from.
current_fruit remains as is. */
if (highest_fruit_id >= 127)
return rnd(127);
f = newfruit();
+ (void) memset((genericptr_t) f, 0, sizeof (struct fruit));
copynchars(f->fname, *altname ? altname : str, PL_FSIZ - 1);
f->fid = ++highest_fruit_id;
/* we used to go out of our way to add it at the end of the list,
but the order is arbitrary so use simpler insertion at start */
f->nextf = ffruit;
ffruit = f;
-nonew:
+ nonew:
if (user_specified)
context.current_fruit = f->fid;
return f->fid;
return ret;
}
-struct wc_Opt wc_options[] = { { "ascii_map", WC_ASCII_MAP },
- { "color", WC_COLOR },
- { "eight_bit_tty", WC_EIGHT_BIT_IN },
- { "hilite_pet", WC_HILITE_PET },
- { "popup_dialog", WC_POPUP_DIALOG },
- { "player_selection", WC_PLAYER_SELECTION },
- { "preload_tiles", WC_PRELOAD_TILES },
- { "tiled_map", WC_TILED_MAP },
- { "tile_file", WC_TILE_FILE },
- { "tile_width", WC_TILE_WIDTH },
- { "tile_height", WC_TILE_HEIGHT },
- { "use_inverse", WC_INVERSE },
- { "align_message", WC_ALIGN_MESSAGE },
- { "align_status", WC_ALIGN_STATUS },
- { "font_map", WC_FONT_MAP },
- { "font_menu", WC_FONT_MENU },
- { "font_message", WC_FONT_MESSAGE },
+static struct wc_Opt wc_options[] = {
+ { "ascii_map", WC_ASCII_MAP },
+ { "color", WC_COLOR },
+ { "eight_bit_tty", WC_EIGHT_BIT_IN },
+ { "hilite_pet", WC_HILITE_PET },
+ { "popup_dialog", WC_POPUP_DIALOG },
+ { "player_selection", WC_PLAYER_SELECTION },
+ { "preload_tiles", WC_PRELOAD_TILES },
+ { "tiled_map", WC_TILED_MAP },
+ { "tile_file", WC_TILE_FILE },
+ { "tile_width", WC_TILE_WIDTH },
+ { "tile_height", WC_TILE_HEIGHT },
+ { "use_inverse", WC_INVERSE },
+ { "align_message", WC_ALIGN_MESSAGE },
+ { "align_status", WC_ALIGN_STATUS },
+ { "font_map", WC_FONT_MAP },
+ { "font_menu", WC_FONT_MENU },
+ { "font_message", WC_FONT_MESSAGE },
#if 0
- {"perm_invent", WC_PERM_INVENT},
-#endif
- { "font_size_map", WC_FONTSIZ_MAP },
- { "font_size_menu", WC_FONTSIZ_MENU },
- { "font_size_message", WC_FONTSIZ_MESSAGE },
- { "font_size_status", WC_FONTSIZ_STATUS },
- { "font_size_text", WC_FONTSIZ_TEXT },
- { "font_status", WC_FONT_STATUS },
- { "font_text", WC_FONT_TEXT },
- { "map_mode", WC_MAP_MODE },
- { "scroll_amount", WC_SCROLL_AMOUNT },
- { "scroll_margin", WC_SCROLL_MARGIN },
- { "splash_screen", WC_SPLASH_SCREEN },
- { "vary_msgcount", WC_VARY_MSGCOUNT },
- { "windowcolors", WC_WINDOWCOLORS },
- { "mouse_support", WC_MOUSE_SUPPORT },
- { (char *) 0, 0L } };
-
-struct wc_Opt wc2_options[] = { { "fullscreen", WC2_FULLSCREEN },
- { "softkeyboard", WC2_SOFTKEYBOARD },
- { "wraptext", WC2_WRAPTEXT },
- { "use_darkgray", WC2_DARKGRAY },
-#ifdef STATUS_VIA_WINDOWPORT
- { "hilite_status", WC2_HILITE_STATUS },
+ {"perm_invent", WC_PERM_INVENT},
#endif
- { (char *) 0, 0L } };
+ { "font_size_map", WC_FONTSIZ_MAP },
+ { "font_size_menu", WC_FONTSIZ_MENU },
+ { "font_size_message", WC_FONTSIZ_MESSAGE },
+ { "font_size_status", WC_FONTSIZ_STATUS },
+ { "font_size_text", WC_FONTSIZ_TEXT },
+ { "font_status", WC_FONT_STATUS },
+ { "font_text", WC_FONT_TEXT },
+ { "map_mode", WC_MAP_MODE },
+ { "scroll_amount", WC_SCROLL_AMOUNT },
+ { "scroll_margin", WC_SCROLL_MARGIN },
+ { "splash_screen", WC_SPLASH_SCREEN },
+ { "vary_msgcount", WC_VARY_MSGCOUNT },
+ { "windowcolors", WC_WINDOWCOLORS },
+ { "mouse_support", WC_MOUSE_SUPPORT },
+ { (char *) 0, 0L }
+};
+static struct wc_Opt wc2_options[] = {
+ { "fullscreen", WC2_FULLSCREEN },
+ { "softkeyboard", WC2_SOFTKEYBOARD },
+ { "wraptext", WC2_WRAPTEXT },
+ { "use_darkgray", WC2_DARKGRAY },
+ { "hitpointbar", WC2_HITPOINTBAR },
+ { "hilite_status", WC2_HILITE_STATUS },
+ /* name shown in 'O' menu is different */
+ { "status hilite rules", WC2_HILITE_STATUS },
+ /* statushilites doesn't have its own bit */
+ { "statushilites", WC2_HILITE_STATUS },
+ { (char *) 0, 0L }
+};
/*
* If a port wants to change or ensure that the SET_IN_SYS,
wc_supported(optnam)
const char *optnam;
{
- int k = 0;
+ int k;
- while (wc_options[k].wc_name) {
- if (!strcmp(wc_options[k].wc_name, optnam)
- && (windowprocs.wincap & wc_options[k].wc_bit))
- return TRUE;
- k++;
+ for (k = 0; wc_options[k].wc_name; ++k) {
+ if (!strcmp(wc_options[k].wc_name, optnam))
+ return (windowprocs.wincap & wc_options[k].wc_bit) ? TRUE : FALSE;
}
return FALSE;
}
wc2_supported(optnam)
const char *optnam;
{
- int k = 0;
+ int k;
- while (wc2_options[k].wc_name) {
- if (!strcmp(wc2_options[k].wc_name, optnam)
- && (windowprocs.wincap2 & wc2_options[k].wc_bit))
- return TRUE;
- k++;
+ for (k = 0; wc2_options[k].wc_name; ++k) {
+ if (!strcmp(wc2_options[k].wc_name, optnam))
+ return (windowprocs.wincap2 & wc2_options[k].wc_bit) ? TRUE
+ : FALSE;
}
return FALSE;
}
OSDN Git Service
