Source:NetHack 3.4.3/src/options.c
Revision as of 14:42, 4 March 2008 by Kernigh bot (talk | contribs) (Options.c moved to Source:Options.c: Robot: moved page)
Below is the full text to src/options.c from NetHack 3.4.3. To link to a particular line, write [[options.c#line123]], for example.
Contents
- 1 Top of file
- 2 Bool_Opt
- 3 Comp_Opt
- 4 Menu accelerators
- 5 match_optname
- 6 nh_getenv
- 7 initoptions
- 8 nmcpy
- 9 escapes
- 10 rejectoption
- 11 badoption
- 12 string_for_opt
- 13 string_for_env_opt
- 14 bad_negation
- 15 change_inv_order
- 16 graphics_opts
- 17 warning_opts
- 18 assign_warnings
- 19 feature_alert_opts
- 20 set_duplicate_opt_detection
- 21 duplicate_opt_detection
- 22 parseoptions
- 23 oc_to_str
- 24 add_menu_cmd_alias
- 25 map_menu_cmd
- 26 doset_add_menu
- 27 doset
- 28 special_handling
- 29 get_compopbt_value
- 30 dotogglepickup
- 31 add_autopickup_exception
- 32 remove_autopickuo_exception
- 33 count_ape_maps
- 34 free_autopickup_exceptions
- 35 option_help
- 36 next_opt
- 37 fruitadd
- 38 choose_classes_menu
- 39 set_option_mod_status
- 40 set_wc_option_mod_status
- 41 is_wc_option
- 42 wc_supported
- 43 set_wc2_option_mod_status
- 44 is_wc2_option
- 45 wc2_supported
- 46 wc_set_font_name
- 47 wc_set_window_colors
Top of file
1. /* SCCS Id: @(#)options.c 3.4 2003/11/14 */ 2. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */ 3. /* NetHack may be freely redistributed. See license for details. */ 4.
The NetHack General Public License applies to screenshots, source code and other content from NetHack.
This content was modified from the original NetHack source code distribution (by splitting up NetHack content between wiki pages, and possibly further editing). See the page history for a list of who changed it, and on what dates.
5. #ifdef OPTION_LISTS_ONLY /* (AMIGA) external program for opt lists */ 6. #include "config.h" 7. #include "objclass.h" 8. #include "flag.h" 9. NEARDATA struct flag flags; /* provide linkage */ 10. NEARDATA struct instance_flags iflags; /* provide linkage */ 11. #define static 12. #else 13. #include "hack.h" 14. #include "tcap.h" 15. #include <ctype.h> 16. #endif 17. 18. #define WINTYPELEN 16 19. 20. #ifdef DEFAULT_WC_TILED_MAP 21. #define PREFER_TILED TRUE 22. #else 23. #define PREFER_TILED FALSE 24. #endif 25.
Bool_Opt
26. /* 27. * NOTE: If you add (or delete) an option, please update the short 28. * options help (option_help()), the long options help (dat/opthelp), 29. * and the current options setting display function (doset()), 30. * and also the Guidebooks. 31. * 32. * The order matters. If an option is a an initial substring of another 33. * option (e.g. time and timed_delay) the shorter one must come first. 34. */ 35. 36. static struct Bool_Opt 37. { 38. const char *name; 39. boolean *addr, initvalue; 40. int optflags; 41. } boolopt[] = { 42. #ifdef AMIGA 43. {"altmeta", &flags.altmeta, TRUE, DISP_IN_GAME}, 44. #else 45. {"altmeta", (boolean *)0, TRUE, DISP_IN_GAME}, 46. #endif 47. {"ascii_map", &iflags.wc_ascii_map, !PREFER_TILED, SET_IN_GAME}, /*WC*/ 48. #ifdef MFLOPPY 49. {"asksavedisk", &flags.asksavedisk, FALSE, SET_IN_GAME}, 50. #else 51. {"asksavedisk", (boolean *)0, FALSE, SET_IN_FILE}, 52. #endif 53. {"autodig", &flags.autodig, FALSE, SET_IN_GAME}, 54. {"autopickup", &flags.pickup, TRUE, SET_IN_GAME}, 55. {"autoquiver", &flags.autoquiver, FALSE, SET_IN_GAME}, 56. #if defined(MICRO) && !defined(AMIGA) 57. {"BIOS", &iflags.BIOS, FALSE, SET_IN_FILE}, 58. #else 59. {"BIOS", (boolean *)0, FALSE, SET_IN_FILE}, 60. #endif 61. #ifdef INSURANCE 62. {"checkpoint", &flags.ins_chkpt, TRUE, SET_IN_GAME}, 63. #else 64. {"checkpoint", (boolean *)0, FALSE, SET_IN_FILE}, 65. #endif 66. #ifdef MFLOPPY 67. {"checkspace", &iflags.checkspace, TRUE, SET_IN_GAME}, 68. #else 69. {"checkspace", (boolean *)0, FALSE, SET_IN_FILE}, 70. #endif 71. {"cmdassist", &iflags.cmdassist, TRUE, SET_IN_GAME}, 72. # if defined(MICRO) || defined(WIN32) 73. {"color", &iflags.wc_color,TRUE, SET_IN_GAME}, /*WC*/ 74. # else /* systems that support multiple terminals, many monochrome */ 75. {"color", &iflags.wc_color, FALSE, SET_IN_GAME}, /*WC*/ 76. # endif 77. {"confirm",&flags.confirm, TRUE, SET_IN_GAME}, 78. #if defined(TERMLIB) && !defined(MAC_GRAPHICS_ENV) 79. {"DECgraphics", &iflags.DECgraphics, FALSE, SET_IN_GAME}, 80. #else 81. {"DECgraphics", (boolean *)0, FALSE, SET_IN_FILE}, 82. #endif 83. {"eight_bit_tty", &iflags.wc_eight_bit_input, FALSE, SET_IN_GAME}, /*WC*/ 84. #ifdef TTY_GRAPHICS 85. {"extmenu", &iflags.extmenu, FALSE, SET_IN_GAME}, 86. #else 87. {"extmenu", (boolean *)0, FALSE, SET_IN_FILE}, 88. #endif 89. #ifdef OPT_DISPMAP 90. {"fast_map", &flags.fast_map, TRUE, SET_IN_GAME}, 91. #else 92. {"fast_map", (boolean *)0, TRUE, SET_IN_FILE}, 93. #endif 94. {"female", &flags.female, FALSE, DISP_IN_GAME}, 95. {"fixinv", &flags.invlet_constant, TRUE, SET_IN_GAME}, 96. #ifdef AMIFLUSH 97. {"flush", &flags.amiflush, FALSE, SET_IN_GAME}, 98. #else 99. {"flush", (boolean *)0, FALSE, SET_IN_FILE}, 100. #endif 101. {"fullscreen", &iflags.wc2_fullscreen, FALSE, SET_IN_FILE}, 102. {"help", &flags.help, TRUE, SET_IN_GAME}, 103. {"hilite_pet", &iflags.wc_hilite_pet, FALSE, SET_IN_GAME}, /*WC*/ 104. #ifdef ASCIIGRAPH 105. {"IBMgraphics", &iflags.IBMgraphics, FALSE, SET_IN_GAME}, 106. #else 107. {"IBMgraphics", (boolean *)0, FALSE, SET_IN_FILE}, 108. #endif 109. #ifndef MAC 110. {"ignintr", &flags.ignintr, FALSE, SET_IN_GAME}, 111. #else 112. {"ignintr", (boolean *)0, FALSE, SET_IN_FILE}, 113. #endif 114. {"large_font", &iflags.obsolete, FALSE, SET_IN_FILE}, /* OBSOLETE */ 115. {"legacy", &flags.legacy, TRUE, DISP_IN_GAME}, 116. {"lit_corridor", &flags.lit_corridor, FALSE, SET_IN_GAME}, 117. {"lootabc", &iflags.lootabc, FALSE, SET_IN_GAME}, 118. #ifdef MAC_GRAPHICS_ENV 119. {"Macgraphics", &iflags.MACgraphics, TRUE, SET_IN_GAME}, 120. #else 121. {"Macgraphics", (boolean *)0, FALSE, SET_IN_FILE}, 122. #endif 123. #ifdef MAIL 124. {"mail", &flags.biff, TRUE, SET_IN_GAME}, 125. #else 126. {"mail", (boolean *)0, TRUE, SET_IN_FILE}, 127. #endif 128. #ifdef WIZARD 129. /* for menu debugging only*/ 130. {"menu_tab_sep", &iflags.menu_tab_sep, FALSE, SET_IN_GAME}, 131. #else 132. {"menu_tab_sep", (boolean *)0, FALSE, SET_IN_FILE}, 133. #endif 134. {"mouse_support", &iflags.wc_mouse_support, TRUE, DISP_IN_GAME}, /*WC*/ 135. #ifdef NEWS 136. {"news", &iflags.news, TRUE, DISP_IN_GAME}, 137. #else 138. {"news", (boolean *)0, FALSE, SET_IN_FILE}, 139. #endif 140. {"null", &flags.null, TRUE, SET_IN_GAME}, 141. #ifdef MAC 142. {"page_wait", &flags.page_wait, TRUE, SET_IN_GAME}, 143. #else 144. {"page_wait", (boolean *)0, FALSE, SET_IN_FILE}, 145. #endif 146. {"perm_invent", &flags.perm_invent, FALSE, SET_IN_GAME}, 147. {"popup_dialog", &iflags.wc_popup_dialog, FALSE, SET_IN_GAME}, /*WC*/ 148. {"prayconfirm", &flags.prayconfirm, TRUE, SET_IN_GAME}, 149. {"preload_tiles", &iflags.wc_preload_tiles, TRUE, DISP_IN_GAME}, /*WC*/ 150. {"pushweapon", &flags.pushweapon, FALSE, SET_IN_GAME}, 151. #if defined(MICRO) && !defined(AMIGA) 152. {"rawio", &iflags.rawio, FALSE, DISP_IN_GAME}, 153. #else 154. {"rawio", (boolean *)0, FALSE, SET_IN_FILE}, 155. #endif 156. {"rest_on_space", &flags.rest_on_space, FALSE, SET_IN_GAME}, 157. {"safe_pet", &flags.safe_dog, TRUE, SET_IN_GAME}, 158. #ifdef WIZARD 159. {"sanity_check", &iflags.sanity_check, FALSE, SET_IN_GAME}, 160. #else 161. {"sanity_check", (boolean *)0, FALSE, SET_IN_FILE}, 162. #endif 163. #ifdef EXP_ON_BOTL 164. {"showexp", &flags.showexp, FALSE, SET_IN_GAME}, 165. #else 166. {"showexp", (boolean *)0, FALSE, SET_IN_FILE}, 167. #endif 168. {"showrace", &iflags.showrace, FALSE, SET_IN_GAME}, 169. #ifdef SCORE_ON_BOTL 170. {"showscore", &flags.showscore, FALSE, SET_IN_GAME}, 171. #else 172. {"showscore", (boolean *)0, FALSE, SET_IN_FILE}, 173. #endif 174. {"silent", &flags.silent, TRUE, SET_IN_GAME}, 175. {"softkeyboard", &iflags.wc2_softkeyboard, FALSE, SET_IN_FILE}, 176. {"sortpack", &flags.sortpack, TRUE, SET_IN_GAME}, 177. {"sound", &flags.soundok, TRUE, SET_IN_GAME}, 178. {"sparkle", &flags.sparkle, TRUE, SET_IN_GAME}, 179. {"standout", &flags.standout, FALSE, SET_IN_GAME}, 180. {"splash_screen", &iflags.wc_splash_screen, TRUE, DISP_IN_GAME}, /*WC*/ 181. {"tiled_map", &iflags.wc_tiled_map, PREFER_TILED, DISP_IN_GAME}, /*WC*/ 182. {"time", &flags.time, FALSE, SET_IN_GAME}, 183. #ifdef TIMED_DELAY 184. {"timed_delay", &flags.nap, TRUE, SET_IN_GAME}, 185. #else 186. {"timed_delay", (boolean *)0, FALSE, SET_IN_GAME}, 187. #endif 188. {"tombstone",&flags.tombstone, TRUE, SET_IN_GAME}, 189. {"toptenwin",&flags.toptenwin, FALSE, SET_IN_GAME}, 190. {"travel", &iflags.travelcmd, TRUE, SET_IN_GAME}, 191. #ifdef WIN32CON 192. {"use_inverse", &iflags.wc_inverse, TRUE, SET_IN_GAME}, /*WC*/ 193. #else 194. {"use_inverse", &iflags.wc_inverse, FALSE, SET_IN_GAME}, /*WC*/ 195. #endif 196. {"verbose", &flags.verbose, TRUE, SET_IN_GAME}, 197. {"wraptext", &iflags.wc2_wraptext, FALSE, SET_IN_GAME}, 198. {(char *)0, (boolean *)0, FALSE, 0} 199. }; 200.
Comp_Opt
201. /* compound options, for option_help() and external programs like Amiga 202. * frontend */ 203. static struct Comp_Opt 204. { 205. const char *name, *descr; 206. int size; /* for frontends and such allocating space -- 207. * usually allowed size of data in game, but 208. * occasionally maximum reasonable size for 209. * typing when game maintains information in 210. * a different format */ 211. int optflags; 212. } compopt[] = { 213. { "align", "your starting alignment (lawful, neutral, or chaotic)", 214. 8, DISP_IN_GAME }, 215. { "align_message", "message window alignment", 20, DISP_IN_GAME }, /*WC*/ 216. { "align_status", "status window alignment", 20, DISP_IN_GAME }, /*WC*/ 217. { "altkeyhandler", "alternate key handler", 20, DISP_IN_GAME }, 218. { "boulder", "the symbol to use for displaying boulders", 219. 1, SET_IN_GAME }, 220. { "catname", "the name of your (first) cat (e.g., catname:Tabby)", 221. PL_PSIZ, DISP_IN_GAME }, 222. { "disclose", "the kinds of information to disclose at end of game", 223. sizeof(flags.end_disclose) * 2, 224. SET_IN_GAME }, 225. { "dogname", "the name of your (first) dog (e.g., dogname:Fang)", 226. PL_PSIZ, DISP_IN_GAME }, 227. { "dungeon", "the symbols to use in drawing the dungeon map", 228. MAXDCHARS+1, SET_IN_FILE }, 229. { "effects", "the symbols to use in drawing special effects", 230. MAXECHARS+1, SET_IN_FILE }, 231. { "font_map", "the font to use in the map window", 40, DISP_IN_GAME }, /*WC*/ 232. { "font_menu", "the font to use in menus", 40, DISP_IN_GAME }, /*WC*/ 233. { "font_message", "the font to use in the message window", 234. 40, DISP_IN_GAME }, /*WC*/ 235. { "font_size_map", "the size of the map font", 20, DISP_IN_GAME }, /*WC*/ 236. { "font_size_menu", "the size of the menu font", 20, DISP_IN_GAME }, /*WC*/ 237. { "font_size_message", "the size of the message font", 20, DISP_IN_GAME }, /*WC*/ 238. { "font_size_status", "the size of the status font", 20, DISP_IN_GAME }, /*WC*/ 239. { "font_size_text", "the size of the text font", 20, DISP_IN_GAME }, /*WC*/ 240. { "font_status", "the font to use in status window", 40, DISP_IN_GAME }, /*WC*/ 241. { "font_text", "the font to use in text windows", 40, DISP_IN_GAME }, /*WC*/ 242. { "fruit", "the name of a fruit you enjoy eating", 243. PL_FSIZ, SET_IN_GAME }, 244. { "gender", "your starting gender (male or female)", 245. 8, DISP_IN_GAME }, 246. { "horsename", "the name of your (first) horse (e.g., horsename:Silver)", 247. PL_PSIZ, DISP_IN_GAME }, 248. { "map_mode", "map display mode under Windows", 20, DISP_IN_GAME }, /*WC*/ 249. { "menustyle", "user interface for object selection", 250. MENUTYPELEN, SET_IN_GAME }, 251. { "menu_deselect_all", "deselect all items in a menu", 4, SET_IN_FILE }, 252. { "menu_deselect_page", "deselect all items on this page of a menu", 253. 4, SET_IN_FILE }, 254. { "menu_first_page", "jump to the first page in a menu", 255. 4, SET_IN_FILE }, 256. { "menu_headings", "bold, inverse, or underline headings", 9, SET_IN_GAME }, 257. { "menu_invert_all", "invert all items in a menu", 4, SET_IN_FILE }, 258. { "menu_invert_page", "invert all items on this page of a menu", 259. 4, SET_IN_FILE }, 260. { "menu_last_page", "jump to the last page in a menu", 4, SET_IN_FILE }, 261. { "menu_next_page", "goto the next menu page", 4, SET_IN_FILE }, 262. { "menu_previous_page", "goto the previous menu page", 4, SET_IN_FILE }, 263. { "menu_search", "search for a menu item", 4, SET_IN_FILE }, 264. { "menu_select_all", "select all items in a menu", 4, SET_IN_FILE }, 265. { "menu_select_page", "select all items on this page of a menu", 266. 4, SET_IN_FILE }, 267. { "monsters", "the symbols to use for monsters", 268. MAXMCLASSES, SET_IN_FILE }, 269. { "msghistory", "number of top line messages to save", 270. 5, DISP_IN_GAME }, 271. # ifdef TTY_GRAPHICS 272. {"msg_window", "the type of message window required",1, SET_IN_GAME}, 273. # else 274. {"msg_window", "the type of message window required", 1, SET_IN_FILE}, 275. # endif 276. { "name", "your character's name (e.g., name:Merlin-W)", 277. PL_NSIZ, DISP_IN_GAME }, 278. { "number_pad", "use the number pad", 1, SET_IN_GAME}, 279. { "objects", "the symbols to use for objects", 280. MAXOCLASSES, SET_IN_FILE }, 281. { "packorder", "the inventory order of the items in your pack", 282. MAXOCLASSES, SET_IN_GAME }, 283. #ifdef CHANGE_COLOR 284. { "palette", "palette (00c/880/-fff is blue/yellow/reverse white)", 285. 15 , SET_IN_GAME }, 286. # if defined(MAC) 287. { "hicolor", "same as palette, only order is reversed", 288. 15, SET_IN_FILE }, 289. # endif 290. #endif 291. { "pettype", "your preferred initial pet type", 4, DISP_IN_GAME }, 292. { "pickup_burden", "maximum burden picked up before prompt", 293. 20, SET_IN_GAME }, 294. { "pickup_types", "types of objects to pick up automatically", 295. MAXOCLASSES, SET_IN_GAME }, 296. { "player_selection", "choose character via dialog or prompts", 297. 12, DISP_IN_GAME }, 298. { "race", "your starting race (e.g., Human, Elf)", 299. PL_CSIZ, DISP_IN_GAME }, 300. { "role", "your starting role (e.g., Barbarian, Valkyrie)", 301. PL_CSIZ, DISP_IN_GAME }, 302. { "runmode", "display frequency when `running' or `travelling'", 303. sizeof "teleport", SET_IN_GAME }, 304. { "scores", "the parts of the score list you wish to see", 305. 32, SET_IN_GAME }, 306. { "scroll_amount", "amount to scroll map when scroll_margin is reached", 307. 20, DISP_IN_GAME }, /*WC*/ 308. { "scroll_margin", "scroll map when this far from the edge", 20, DISP_IN_GAME }, /*WC*/ 309. #ifdef MSDOS 310. { "soundcard", "type of sound card to use", 20, SET_IN_FILE }, 311. #endif 312. { "suppress_alert", "suppress alerts about version-specific features", 313. 8, SET_IN_GAME }, 314. { "tile_width", "width of tiles", 20, DISP_IN_GAME}, /*WC*/ 315. { "tile_height", "height of tiles", 20, DISP_IN_GAME}, /*WC*/ 316. { "tile_file", "name of tile file", 70, DISP_IN_GAME}, /*WC*/ 317. { "traps", "the symbols to use in drawing traps", 318. MAXTCHARS+1, SET_IN_FILE }, 319. { "vary_msgcount", "show more old messages at a time", 20, DISP_IN_GAME }, /*WC*/ 320. #ifdef MSDOS 321. { "video", "method of video updating", 20, SET_IN_FILE }, 322. #endif 323. #ifdef VIDEOSHADES 324. { "videocolors", "color mappings for internal screen routines", 325. 40, DISP_IN_GAME }, 326. { "videoshades", "gray shades to map to black/gray/white", 327. 32, DISP_IN_GAME }, 328. #endif 329. #ifdef WIN32CON 330. {"subkeyvalue", "override keystroke value", 7, SET_IN_FILE}, 331. #endif 332. { "windowcolors", "the foreground/background colors of windows", /*WC*/ 333. 80, DISP_IN_GAME }, 334. { "windowtype", "windowing system to use", WINTYPELEN, DISP_IN_GAME }, 335. { (char *)0, (char *)0, 0, 0 } 336. }; 337.
338. #ifdef OPTION_LISTS_ONLY 339. #undef static 340. 341. #else /* use rest of file */ 342. 343. static boolean need_redraw; /* for doset() */ 344. 345. #if defined(TOS) && defined(TEXTCOLOR) 346. extern boolean colors_changed; /* in tos.c */ 347. #endif 348. 349. #ifdef VIDEOSHADES 350. extern char *shade[3]; /* in sys/msdos/video.c */ 351. extern char ttycolors[CLR_MAX]; /* in sys/msdos/video.c */ 352. #endif 353. 354. static char def_inv_order[MAXOCLASSES] = { 355. COIN_CLASS, AMULET_CLASS, WEAPON_CLASS, ARMOR_CLASS, FOOD_CLASS, 356. SCROLL_CLASS, SPBOOK_CLASS, POTION_CLASS, RING_CLASS, WAND_CLASS, 357. TOOL_CLASS, GEM_CLASS, ROCK_CLASS, BALL_CLASS, CHAIN_CLASS, 0, 358. }; 359.
Menu accelerators
360. /* 361. * Default menu manipulation command accelerators. These may _not_ be: 362. * 363. * + a number - reserved for counts 364. * + an upper or lower case US ASCII letter - used for accelerators 365. * + ESC - reserved for escaping the menu 366. * + NULL, CR or LF - reserved for commiting the selection(s). NULL 367. * is kind of odd, but the tty's xwaitforspace() will return it if 368. * someone hits a <ret>. 369. * + a default object class symbol - used for object class accelerators 370. * 371. * Standard letters (for now) are: 372. * 373. * < back 1 page 374. * > forward 1 page 375. * ^ first page 376. * | last page 377. * : search 378. * 379. * page all 380. * , select . 381. * \ deselect - 382. * ~ invert @ 383. * 384. * The command name list is duplicated in the compopt array. 385. */ 386. typedef struct { 387. const char *name; 388. char cmd; 389. } menu_cmd_t; 390. 391. #define NUM_MENU_CMDS 11 392. static const menu_cmd_t default_menu_cmd_info[NUM_MENU_CMDS] = { 393. /* 0*/ { "menu_first_page", MENU_FIRST_PAGE }, 394. { "menu_last_page", MENU_LAST_PAGE }, 395. { "menu_next_page", MENU_NEXT_PAGE }, 396. { "menu_previous_page", MENU_PREVIOUS_PAGE }, 397. { "menu_select_all", MENU_SELECT_ALL }, 398. /* 5*/ { "menu_deselect_all", MENU_UNSELECT_ALL }, 399. { "menu_invert_all", MENU_INVERT_ALL }, 400. { "menu_select_page", MENU_SELECT_PAGE }, 401. { "menu_deselect_page", MENU_UNSELECT_PAGE }, 402. { "menu_invert_page", MENU_INVERT_PAGE }, 403. /*10*/ { "menu_search", MENU_SEARCH }, 404. }; 405.
406. /* 407. * Allow the user to map incoming characters to various menu commands. 408. * The accelerator list must be a valid C string. 409. */ 410. #define MAX_MENU_MAPPED_CMDS 32 /* some number */ 411. char mapped_menu_cmds[MAX_MENU_MAPPED_CMDS+1]; /* exported */ 412. static char mapped_menu_op[MAX_MENU_MAPPED_CMDS+1]; 413. static short n_menu_mapped = 0; 414. 415. 416. static boolean initial, from_file; 417. 418. STATIC_DCL void FDECL(doset_add_menu, (winid,const char *,int)); 419. STATIC_DCL void FDECL(nmcpy, (char *, const char *, int)); 420. STATIC_DCL void FDECL(escapes, (const char *, char *)); 421. STATIC_DCL void FDECL(rejectoption, (const char *)); 422. STATIC_DCL void FDECL(badoption, (const char *)); 423. STATIC_DCL char *FDECL(string_for_opt, (char *,BOOLEAN_P)); 424. STATIC_DCL char *FDECL(string_for_env_opt, (const char *, char *,BOOLEAN_P)); 425. STATIC_DCL void FDECL(bad_negation, (const char *,BOOLEAN_P)); 426. STATIC_DCL int FDECL(change_inv_order, (char *)); 427. STATIC_DCL void FDECL(oc_to_str, (char *, char *)); 428. STATIC_DCL void FDECL(graphics_opts, (char *,const char *,int,int)); 429. STATIC_DCL int FDECL(feature_alert_opts, (char *, const char *)); 430. STATIC_DCL const char *FDECL(get_compopt_value, (const char *, char *)); 431. STATIC_DCL boolean FDECL(special_handling, (const char *, BOOLEAN_P, BOOLEAN_P)); 432. STATIC_DCL void FDECL(warning_opts, (char *,const char *)); 433. STATIC_DCL void FDECL(duplicate_opt_detection, (const char *, int)); 434. 435. STATIC_OVL void FDECL(wc_set_font_name, (int, char *)); 436. STATIC_OVL int FDECL(wc_set_window_colors, (char *)); 437. STATIC_OVL boolean FDECL(is_wc_option, (const char *)); 438. STATIC_OVL boolean FDECL(wc_supported, (const char *)); 439. STATIC_OVL boolean FDECL(is_wc2_option, (const char *)); 440. STATIC_OVL boolean FDECL(wc2_supported, (const char *)); 441. #ifdef AUTOPICKUP_EXCEPTIONS 442. STATIC_DCL void FDECL(remove_autopickup_exception, (struct autopickup_exception *)); 443. STATIC_OVL int FDECL(count_ape_maps, (int *, int *)); 444. #endif 445.
match_optname
446. /* check whether a user-supplied option string is a proper leading 447. substring of a particular option name; option string might have 448. a colon or equals sign and arbitrary value appended to it */ 449. boolean 450. match_optname(user_string, opt_name, min_length, val_allowed) 451. const char *user_string, *opt_name; 452. int min_length; 453. boolean val_allowed; 454. { 455. int len = (int)strlen(user_string); 456. 457. if (val_allowed) { 458. const char *p = index(user_string, ':'), 459. *q = index(user_string, '='); 460. 461. if (!p || (q && q < p)) p = q; 462. while(p && p > user_string && isspace(*(p-1))) p--; 463. if (p) len = (int)(p - user_string); 464. } 465. 466. return (len >= min_length) && !strncmpi(opt_name, user_string, len); 467. } 468.
nh_getenv
469. /* most environment variables will eventually be printed in an error 470. * message if they don't work, and most error message paths go through 471. * BUFSZ buffers, which could be overflowed by a maliciously long 472. * environment variable. if a variable can legitimately be long, or 473. * if it's put in a smaller buffer, the responsible code will have to 474. * bounds-check itself. 475. */ 476. char * 477. nh_getenv(ev) 478. const char *ev; 479. { 480. char *getev = getenv(ev); 481. 482. if (getev && strlen(getev) <= (BUFSZ / 2)) 483. return getev; 484. else 485. return (char *)0; 486. } 487.
initoptions
488. void 489. initoptions() 490. { 491. #ifndef MAC 492. char *opts; 493. #endif 494. int i; 495. 496. /* initialize the random number generator */ 497. setrandom(); 498. 499. /* for detection of configfile options specified multiple times */ 500. iflags.opt_booldup = iflags.opt_compdup = (int *)0; 501. 502. for (i = 0; boolopt[i].name; i++) { 503. if (boolopt[i].addr) 504. *(boolopt[i].addr) = boolopt[i].initvalue; 505. } 506. flags.end_own = FALSE; 507. flags.end_top = 3; 508. flags.end_around = 2; 509. iflags.runmode = RUN_LEAP; 510. iflags.msg_history = 20; 511. #ifdef TTY_GRAPHICS 512. iflags.prevmsg_window = 's'; 513. #endif 514. iflags.menu_headings = ATR_INVERSE; 515. 516. /* Use negative indices to indicate not yet selected */ 517. flags.initrole = -1; 518. flags.initrace = -1; 519. flags.initgend = -1; 520. flags.initalign = -1; 521. 522. /* Set the default monster and object class symbols. Don't use */ 523. /* memcpy() --- sizeof char != sizeof uchar on some machines. */ 524. for (i = 0; i < MAXOCLASSES; i++) 525. oc_syms[i] = (uchar) def_oc_syms[i]; 526. for (i = 0; i < MAXMCLASSES; i++) 527. monsyms[i] = (uchar) def_monsyms[i]; 528. for (i = 0; i < WARNCOUNT; i++) 529. warnsyms[i] = def_warnsyms[i].sym; 530. iflags.bouldersym = 0; 531. iflags.travelcc.x = iflags.travelcc.y = -1; 532. flags.warnlevel = 1; 533. flags.warntype = 0L; 534. 535. /* assert( sizeof flags.inv_order == sizeof def_inv_order ); */ 536. (void)memcpy((genericptr_t)flags.inv_order, 537. (genericptr_t)def_inv_order, sizeof flags.inv_order); 538. flags.pickup_types[0] = '\0'; 539. flags.pickup_burden = MOD_ENCUMBER; 540. 541. for (i = 0; i < NUM_DISCLOSURE_OPTIONS; i++) 542. flags.end_disclose[i] = DISCLOSE_PROMPT_DEFAULT_NO; 543. switch_graphics(ASCII_GRAPHICS); /* set default characters */ 544. #if defined(UNIX) && defined(TTY_GRAPHICS) 545. /* 546. * Set defaults for some options depending on what we can 547. * detect about the environment's capabilities. 548. * This has to be done after the global initialization above 549. * and before reading user-specific initialization via 550. * config file/environment variable below. 551. */ 552. /* this detects the IBM-compatible console on most 386 boxes */ 553. if ((opts = nh_getenv("TERM")) && !strncmp(opts, "AT", 2)) { 554. switch_graphics(IBM_GRAPHICS); 555. # ifdef TEXTCOLOR 556. iflags.use_color = TRUE; 557. # endif 558. } 559. #endif /* UNIX && TTY_GRAPHICS */ 560. #if defined(UNIX) || defined(VMS) 561. # ifdef TTY_GRAPHICS 562. /* detect whether a "vt" terminal can handle alternate charsets */ 563. if ((opts = nh_getenv("TERM")) && 564. !strncmpi(opts, "vt", 2) && AS && AE && 565. index(AS, '\016') && index(AE, '\017')) { 566. switch_graphics(DEC_GRAPHICS); 567. } 568. # endif 569. #endif /* UNIX || VMS */ 570. 571. #ifdef MAC_GRAPHICS_ENV 572. switch_graphics(MAC_GRAPHICS); 573. #endif /* MAC_GRAPHICS_ENV */ 574. flags.menu_style = MENU_FULL; 575. 576. /* since this is done before init_objects(), do partial init here */ 577. objects[SLIME_MOLD].oc_name_idx = SLIME_MOLD; 578. nmcpy(pl_fruit, OBJ_NAME(objects[SLIME_MOLD]), PL_FSIZ); 579. #ifndef MAC 580. opts = getenv("NETHACKOPTIONS"); 581. if (!opts) opts = getenv("HACKOPTIONS"); 582. if (opts) { 583. if (*opts == '/' || *opts == '\\' || *opts == '@') { 584. if (*opts == '@') opts++; /* @filename */ 585. /* looks like a filename */ 586. if (strlen(opts) < BUFSZ/2) 587. read_config_file(opts); 588. } else { 589. read_config_file((char *)0); 590. /* let the total length of options be long; 591. * parseoptions() will check each individually 592. */ 593. parseoptions(opts, TRUE, FALSE); 594. } 595. } else 596. #endif 597. read_config_file((char *)0); 598. 599. (void)fruitadd(pl_fruit); 600. /* Remove "slime mold" from list of object names; this will */ 601. /* prevent it from being wished unless it's actually present */ 602. /* as a named (or default) fruit. Wishing for "fruit" will */ 603. /* result in the player's preferred fruit [better than "\033"]. */ 604. obj_descr[SLIME_MOLD].oc_name = "fruit"; 605. 606. return; 607. } 608.
nmcpy
609. STATIC_OVL void 610. nmcpy(dest, src, maxlen) 611. char *dest; 612. const char *src; 613. int maxlen; 614. { 615. int count; 616. 617. for(count = 1; count < maxlen; count++) { 618. if(*src == ',' || *src == '\0') break; /*exit on \0 terminator*/ 619. *dest++ = *src++; 620. } 621. *dest = 0; 622. } 623.
escapes
624. /* 625. * escapes: escape expansion for showsyms. C-style escapes understood include 626. * \n, \b, \t, \r, \xnnn (hex), \onnn (octal), \nnn (decimal). The ^-prefix 627. * for control characters is also understood, and \[mM] followed by any of the 628. * previous forms or by a character has the effect of 'meta'-ing the value (so 629. * that the alternate character set will be enabled). 630. */ 631. STATIC_OVL void 632. escapes(cp, tp) 633. const char *cp; 634. char *tp; 635. { 636. while (*cp) 637. { 638. int cval = 0, meta = 0; 639. 640. if (*cp == '\\' && index("mM", cp[1])) { 641. meta = 1; 642. cp += 2; 643. } 644. if (*cp == '\\' && index("0123456789xXoO", cp[1])) 645. { 646. const char *dp, *hex = "00112233445566778899aAbBcCdDeEfF"; 647. int dcount = 0; 648. 649. cp++; 650. if (*cp == 'x' || *cp == 'X') 651. for (++cp; (dp = index(hex, *cp)) && (dcount++ < 2); cp++) 652. cval = (cval * 16) + (dp - hex) / 2; 653. else if (*cp == 'o' || *cp == 'O') 654. for (++cp; (index("01234567",*cp)) && (dcount++ < 3); cp++) 655. cval = (cval * 8) + (*cp - '0'); 656. else 657. for (; (index("0123456789",*cp)) && (dcount++ < 3); cp++) 658. cval = (cval * 10) + (*cp - '0'); 659. } 660. else if (*cp == '\\') /* C-style character escapes */ 661. { 662. switch (*++cp) 663. { 664. case '\\': cval = '\\'; break; 665. case 'n': cval = '\n'; break; 666. case 't': cval = '\t'; break; 667. case 'b': cval = '\b'; break; 668. case 'r': cval = '\r'; break; 669. default: cval = *cp; 670. } 671. cp++; 672. } 673. else if (*cp == '^') /* expand control-character syntax */ 674. { 675. cval = (*++cp & 0x1f); 676. cp++; 677. } 678. else 679. cval = *cp++; 680. if (meta) 681. cval |= 0x80; 682. *tp++ = cval; 683. } 684. *tp = '\0'; 685. } 686.
rejectoption
687. STATIC_OVL void 688. rejectoption(optname) 689. const char *optname; 690. { 691. #ifdef MICRO 692. pline("\"%s\" settable only from %s.", optname, configfile); 693. #else 694. pline("%s can be set only from NETHACKOPTIONS or %s.", optname, 695. configfile); 696. #endif 697. } 698.
badoption
699. STATIC_OVL void 700. badoption(opts) 701. const char *opts; 702. { 703. if (!initial) { 704. if (!strncmp(opts, "h", 1) || !strncmp(opts, "?", 1)) 705. option_help(); 706. else 707. pline("Bad syntax: %s. Enter \"?g\" for help.", opts); 708. return; 709. } 710. #ifdef MAC 711. else return; 712. #endif 713. 714. if(from_file) 715. raw_printf("Bad syntax in OPTIONS in %s: %s.", configfile, opts); 716. else 717. raw_printf("Bad syntax in NETHACKOPTIONS: %s.", opts); 718. 719. wait_synch(); 720. } 721.
string_for_opt
722. STATIC_OVL char * 723. string_for_opt(opts, val_optional) 724. char *opts; 725. boolean val_optional; 726. { 727. char *colon, *equals; 728. 729. colon = index(opts, ':'); 730. equals = index(opts, '='); 731. if (!colon || (equals && equals < colon)) colon = equals; 732. 733. if (!colon || !*++colon) { 734. if (!val_optional) badoption(opts); 735. return (char *)0; 736. } 737. return colon; 738. } 739.
string_for_env_opt
740. STATIC_OVL char * 741. string_for_env_opt(optname, opts, val_optional) 742. const char *optname; 743. char *opts; 744. boolean val_optional; 745. { 746. if(!initial) { 747. rejectoption(optname); 748. return (char *)0; 749. } 750. return string_for_opt(opts, val_optional); 751. } 752.
bad_negation
753. STATIC_OVL void 754. bad_negation(optname, with_parameter) 755. const char *optname; 756. boolean with_parameter; 757. { 758. pline_The("%s option may not %sbe negated.", 759. optname, 760. with_parameter ? "both have a value and " : ""); 761. } 762.
change_inv_order
763. /* 764. * Change the inventory order, using the given string as the new order. 765. * Missing characters in the new order are filled in at the end from 766. * the current inv_order, except for gold, which is forced to be first 767. * if not explicitly present. 768. * 769. * This routine returns 1 unless there is a duplicate or bad char in 770. * the string. 771. */ 772. STATIC_OVL int 773. change_inv_order(op) 774. char *op; 775. { 776. int oc_sym, num; 777. char *sp, buf[BUFSZ]; 778. 779. num = 0; 780. #ifndef GOLDOBJ 781. if (!index(op, GOLD_SYM)) 782. buf[num++] = COIN_CLASS; 783. #else 784. /* !!!! probably unnecessary with gold as normal inventory */ 785. #endif 786. 787. for (sp = op; *sp; sp++) { 788. oc_sym = def_char_to_objclass(*sp); 789. /* reject bad or duplicate entries */ 790. if (oc_sym == MAXOCLASSES || 791. oc_sym == RANDOM_CLASS || oc_sym == ILLOBJ_CLASS || 792. !index(flags.inv_order, oc_sym) || index(sp+1, *sp)) 793. return 0; 794. /* retain good ones */ 795. buf[num++] = (char) oc_sym; 796. } 797. buf[num] = '\0'; 798. 799. /* fill in any omitted classes, using previous ordering */ 800. for (sp = flags.inv_order; *sp; sp++) 801. if (!index(buf, *sp)) { 802. buf[num++] = *sp; 803. buf[num] = '\0'; /* explicitly terminate for next index() */ 804. } 805. 806. Strcpy(flags.inv_order, buf); 807. return 1; 808. } 809.
graphics_opts
810. STATIC_OVL void 811. graphics_opts(opts, optype, maxlen, offset) 812. register char *opts; 813. const char *optype; 814. int maxlen, offset; 815. { 816. uchar translate[MAXPCHARS+1]; 817. int length, i; 818. 819. if (!(opts = string_for_env_opt(optype, opts, FALSE))) 820. return; 821. escapes(opts, opts); 822. 823. length = strlen(opts); 824. if (length > maxlen) length = maxlen; 825. /* match the form obtained from PC configuration files */ 826. for (i = 0; i < length; i++) 827. translate[i] = (uchar) opts[i]; 828. assign_graphics(translate, length, maxlen, offset); 829. } 830.
warning_opts
831. STATIC_OVL void 832. warning_opts(opts, optype) 833. register char *opts; 834. const char *optype; 835. { 836. uchar translate[MAXPCHARS+1]; 837. int length, i; 838. 839. if (!(opts = string_for_env_opt(optype, opts, FALSE))) 840. return; 841. escapes(opts, opts); 842. 843. length = strlen(opts); 844. if (length > WARNCOUNT) length = WARNCOUNT; 845. /* match the form obtained from PC configuration files */ 846. for (i = 0; i < length; i++) 847. translate[i] = (((i < WARNCOUNT) && opts[i]) ? 848. (uchar) opts[i] : def_warnsyms[i].sym); 849. assign_warnings(translate); 850. } 851.
assign_warnings
852. void 853. assign_warnings(graph_chars) 854. register uchar *graph_chars; 855. { 856. int i; 857. for (i = 0; i < WARNCOUNT; i++) 858. if (graph_chars[i]) warnsyms[i] = graph_chars[i]; 859. } 860.
feature_alert_opts
861. STATIC_OVL int 862. feature_alert_opts(op, optn) 863. char *op; 864. const char *optn; 865. { 866. char buf[BUFSZ]; 867. boolean rejectver = FALSE; 868. unsigned long fnv = get_feature_notice_ver(op); /* version.c */ 869. if (fnv == 0L) return 0; 870. if (fnv > get_current_feature_ver()) 871. rejectver = TRUE; 872. else 873. flags.suppress_alert = fnv; 874. if (rejectver) { 875. if (!initial) 876. You_cant("disable new feature alerts for future versions."); 877. else { 878. Sprintf(buf, 879. "\n%s=%s Invalid reference to a future version ignored", 880. optn, op); 881. badoption(buf); 882. } 883. return 0; 884. } 885. if (!initial) { 886. Sprintf(buf, "%lu.%lu.%lu", FEATURE_NOTICE_VER_MAJ, 887. FEATURE_NOTICE_VER_MIN, FEATURE_NOTICE_VER_PATCH); 888. pline("Feature change alerts disabled for NetHack %s features and prior.", 889. buf); 890. } 891. return 1; 892. } 893.
set_duplicate_opt_detection
894. void 895. set_duplicate_opt_detection(on_or_off) 896. int on_or_off; 897. { 898. int k, *optptr; 899. if (on_or_off != 0) { 900. /*-- ON --*/ 901. if (iflags.opt_booldup) 902. impossible("iflags.opt_booldup already on (memory leak)"); 903. iflags.opt_booldup = (int *)alloc(SIZE(boolopt) * sizeof(int)); 904. optptr = iflags.opt_booldup; 905. for (k = 0; k < SIZE(boolopt); ++k) 906. *optptr++ = 0; 907. 908. if (iflags.opt_compdup) 909. impossible("iflags.opt_compdup already on (memory leak)"); 910. iflags.opt_compdup = (int *)alloc(SIZE(compopt) * sizeof(int)); 911. optptr = iflags.opt_compdup; 912. for (k = 0; k < SIZE(compopt); ++k) 913. *optptr++ = 0; 914. } else { 915. /*-- OFF --*/ 916. if (iflags.opt_booldup) free((genericptr_t) iflags.opt_booldup); 917. iflags.opt_booldup = (int *)0; 918. if (iflags.opt_compdup) free((genericptr_t) iflags.opt_compdup); 919. iflags.opt_compdup = (int *)0; 920. } 921. } 922.
duplicate_opt_detection
923. STATIC_OVL void 924. duplicate_opt_detection(opts, bool_or_comp) 925. const char *opts; 926. int bool_or_comp; /* 0 == boolean option, 1 == compound */ 927. { 928. int i, *optptr; 929. #if defined(MAC) 930. /* the Mac has trouble dealing with the output of messages while 931. * processing the config file. That should get fixed one day. 932. * For now just return. 933. */ 934. return; 935. #endif 936. if ((bool_or_comp == 0) && iflags.opt_booldup && initial && from_file) { 937. for (i = 0; boolopt[i].name; i++) { 938. if (match_optname(opts, boolopt[i].name, 3, FALSE)) { 939. optptr = iflags.opt_booldup + i; 940. if (*optptr == 1) { 941. raw_printf( 942. "\nWarning - Boolean option specified multiple times: %s.\n", 943. opts); 944. wait_synch(); 945. } 946. *optptr += 1; 947. break; /* don't match multiple options */ 948. } 949. } 950. } else if ((bool_or_comp == 1) && iflags.opt_compdup && initial && from_file) { 951. for (i = 0; compopt[i].name; i++) { 952. if (match_optname(opts, compopt[i].name, strlen(compopt[i].name), TRUE)) { 953. optptr = iflags.opt_compdup + i; 954. if (*optptr == 1) { 955. raw_printf( 956. "\nWarning - compound option specified multiple times: %s.\n", 957. compopt[i].name); 958. wait_synch(); 959. } 960. *optptr += 1; 961. break; /* don't match multiple options */ 962. } 963. } 964. } 965. } 966.
parseoptions
967. void 968. parseoptions(opts, tinitial, tfrom_file) 969. register char *opts; 970. boolean tinitial, tfrom_file; 971. { 972. register char *op; 973. unsigned num; 974. boolean negated; 975. int i; 976. const char *fullname; 977. 978. initial = tinitial; 979. from_file = tfrom_file; 980. if ((op = index(opts, ',')) != 0) { 981. *op++ = 0; 982. parseoptions(op, initial, from_file); 983. } 984. if (strlen(opts) > BUFSZ/2) { 985. badoption("option too long"); 986. return; 987. } 988. 989. /* strip leading and trailing white space */ 990. while (isspace(*opts)) opts++; 991. op = eos(opts); 992. while (--op >= opts && isspace(*op)) *op = '\0'; 993. 994. if (!*opts) return; 995. negated = FALSE; 996. while ((*opts == '!') || !strncmpi(opts, "no", 2)) { 997. if (*opts == '!') opts++; else opts += 2; 998. negated = !negated; 999. } 1000. 1001. /* variant spelling */ 1002. 1003. if (match_optname(opts, "colour", 5, FALSE)) 1004. Strcpy(opts, "color"); /* fortunately this isn't longer */ 1005. 1006. if (!match_optname(opts, "subkeyvalue", 11, TRUE)) /* allow multiple */ 1007. duplicate_opt_detection(opts, 1); /* 1 means compound opts */ 1008. 1009. /* special boolean options */ 1010. 1011. if (match_optname(opts, "female", 3, FALSE)) { 1012. if(!initial && flags.female == negated) 1013. pline("That is not anatomically possible."); 1014. else 1015. flags.initgend = flags.female = !negated; 1016. return; 1017. } 1018. 1019. if (match_optname(opts, "male", 4, FALSE)) { 1020. if(!initial && flags.female != negated) 1021. pline("That is not anatomically possible."); 1022. else 1023. flags.initgend = flags.female = negated; 1024. return; 1025. } 1026. 1027. #if defined(MICRO) && !defined(AMIGA) 1028. /* included for compatibility with old NetHack.cnf files */ 1029. if (match_optname(opts, "IBM_", 4, FALSE)) { 1030. iflags.BIOS = !negated; 1031. return; 1032. } 1033. #endif /* MICRO */ 1034. 1035. /* compound options */ 1036. 1037. fullname = "pettype"; 1038. if (match_optname(opts, fullname, 3, TRUE)) { 1039. if ((op = string_for_env_opt(fullname, opts, negated)) != 0) { 1040. if (negated) bad_negation(fullname, TRUE); 1041. else switch (*op) { 1042. case 'd': /* dog */ 1043. case 'D': 1044. preferred_pet = 'd'; 1045. break; 1046. case 'c': /* cat */ 1047. case 'C': 1048. case 'f': /* feline */ 1049. case 'F': 1050. preferred_pet = 'c'; 1051. break; 1052. case 'n': /* no pet */ 1053. case 'N': 1054. preferred_pet = 'n'; 1055. break; 1056. default: 1057. pline("Unrecognized pet type '%s'.", op); 1058. break; 1059. } 1060. } else if (negated) preferred_pet = 'n'; 1061. return; 1062. } 1063. 1064. fullname = "catname"; 1065. if (match_optname(opts, fullname, 3, TRUE)) { 1066. if (negated) bad_negation(fullname, FALSE); 1067. else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) 1068. nmcpy(catname, op, PL_PSIZ); 1069. return; 1070. } 1071. 1072. fullname = "dogname"; 1073. if (match_optname(opts, fullname, 3, TRUE)) { 1074. if (negated) bad_negation(fullname, FALSE); 1075. else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) 1076. nmcpy(dogname, op, PL_PSIZ); 1077. return; 1078. } 1079. 1080. fullname = "horsename"; 1081. if (match_optname(opts, fullname, 5, TRUE)) { 1082. if (negated) bad_negation(fullname, FALSE); 1083. else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) 1084. nmcpy(horsename, op, PL_PSIZ); 1085. return; 1086. } 1087. 1088. fullname = "number_pad"; 1089. if (match_optname(opts, fullname, 10, TRUE)) { 1090. boolean compat = (strlen(opts) <= 10); 1091. number_pad(iflags.num_pad ? 1 : 0); 1092. op = string_for_opt(opts, (compat || !initial)); 1093. if (!op) { 1094. if (compat || negated || initial) { 1095. /* for backwards compatibility, "number_pad" without a 1096. value is a synonym for number_pad:1 */ 1097. iflags.num_pad = !negated; 1098. if (iflags.num_pad) iflags.num_pad_mode = 0; 1099. } 1100. return; 1101. } 1102. if (negated) { 1103. bad_negation("number_pad", TRUE); 1104. return; 1105. } 1106. if (*op == '1' || *op == '2') { 1107. iflags.num_pad = 1; 1108. if (*op == '2') iflags.num_pad_mode = 1; 1109. else iflags.num_pad_mode = 0; 1110. } else if (*op == '0') { 1111. iflags.num_pad = 0; 1112. iflags.num_pad_mode = 0; 1113. } else badoption(opts); 1114. return; 1115. } 1116. 1117. fullname = "runmode"; 1118. if (match_optname(opts, fullname, 4, TRUE)) { 1119. if (negated) { 1120. iflags.runmode = RUN_TPORT; 1121. } else if ((op = string_for_opt(opts, FALSE)) != 0) { 1122. if (!strncmpi(op, "teleport", strlen(op))) 1123. iflags.runmode = RUN_TPORT; 1124. else if (!strncmpi(op, "run", strlen(op))) 1125. iflags.runmode = RUN_LEAP; 1126. else if (!strncmpi(op, "walk", strlen(op))) 1127. iflags.runmode = RUN_STEP; 1128. else if (!strncmpi(op, "crawl", strlen(op))) 1129. iflags.runmode = RUN_CRAWL; 1130. else 1131. badoption(opts); 1132. } 1133. return; 1134. } 1135. 1136. fullname = "msghistory"; 1137. if (match_optname(opts, fullname, 3, TRUE)) { 1138. op = string_for_env_opt(fullname, opts, negated); 1139. if ((negated && !op) || (!negated && op)) { 1140. iflags.msg_history = negated ? 0 : atoi(op); 1141. } else if (negated) bad_negation(fullname, TRUE); 1142. return; 1143. } 1144. 1145. fullname="msg_window"; 1146. /* msg_window:single, combo, full or reversed */ 1147. if (match_optname(opts, fullname, 4, TRUE)) { 1148. /* allow option to be silently ignored by non-tty ports */ 1149. #ifdef TTY_GRAPHICS 1150. int tmp; 1151. if (!(op = string_for_opt(opts, TRUE))) { 1152. tmp = negated ? 's' : 'f'; 1153. } else { 1154. if (negated) { 1155. bad_negation(fullname, TRUE); 1156. return; 1157. } 1158. tmp = tolower(*op); 1159. } 1160. switch (tmp) { 1161. case 's': /* single message history cycle (default if negated) */ 1162. iflags.prevmsg_window = 's'; 1163. break; 1164. case 'c': /* combination: two singles, then full page reversed */ 1165. iflags.prevmsg_window = 'c'; 1166. break; 1167. case 'f': /* full page (default if no opts) */ 1168. iflags.prevmsg_window = 'f'; 1169. break; 1170. case 'r': /* full page (reversed) */ 1171. iflags.prevmsg_window = 'r'; 1172. break; 1173. default: 1174. badoption(opts); 1175. } 1176. #endif 1177. return; 1178. } 1179. 1180. /* WINCAP 1181. * setting font options */ 1182. fullname = "font"; 1183. if (!strncmpi(opts, fullname, 4)) 1184. { 1185. int wintype = -1; 1186. char *fontopts = opts + 4; 1187. 1188. if (!strncmpi(fontopts, "map", 3) || 1189. !strncmpi(fontopts, "_map", 4)) 1190. wintype = NHW_MAP; 1191. else if (!strncmpi(fontopts, "message", 7) || 1192. !strncmpi(fontopts, "_message", 8)) 1193. wintype = NHW_MESSAGE; 1194. else if (!strncmpi(fontopts, "text", 4) || 1195. !strncmpi(fontopts, "_text", 5)) 1196. wintype = NHW_TEXT; 1197. else if (!strncmpi(fontopts, "menu", 4) || 1198. !strncmpi(fontopts, "_menu", 5)) 1199. wintype = NHW_MENU; 1200. else if (!strncmpi(fontopts, "status", 6) || 1201. !strncmpi(fontopts, "_status", 7)) 1202. wintype = NHW_STATUS; 1203. else if (!strncmpi(fontopts, "_size", 5)) { 1204. if (!strncmpi(fontopts, "_size_map", 8)) 1205. wintype = NHW_MAP; 1206. else if (!strncmpi(fontopts, "_size_message", 12)) 1207. wintype = NHW_MESSAGE; 1208. else if (!strncmpi(fontopts, "_size_text", 9)) 1209. wintype = NHW_TEXT; 1210. else if (!strncmpi(fontopts, "_size_menu", 9)) 1211. wintype = NHW_MENU; 1212. else if (!strncmpi(fontopts, "_size_status", 11)) 1213. wintype = NHW_STATUS; 1214. else { 1215. badoption(opts); 1216. return; 1217. } 1218. if (wintype > 0 && !negated && 1219. (op = string_for_opt(opts, FALSE)) != 0) { 1220. switch(wintype) { 1221. case NHW_MAP: 1222. iflags.wc_fontsiz_map = atoi(op); 1223. break; 1224. case NHW_MESSAGE: 1225. iflags.wc_fontsiz_message = atoi(op); 1226. break; 1227. case NHW_TEXT: 1228. iflags.wc_fontsiz_text = atoi(op); 1229. break; 1230. case NHW_MENU: 1231. iflags.wc_fontsiz_menu = atoi(op); 1232. break; 1233. case NHW_STATUS: 1234. iflags.wc_fontsiz_status = atoi(op); 1235. break; 1236. } 1237. } 1238. return; 1239. } else { 1240. badoption(opts); 1241. } 1242. if (wintype > 0 && 1243. (op = string_for_opt(opts, FALSE)) != 0) { 1244. wc_set_font_name(wintype, op); 1245. #ifdef MAC 1246. set_font_name (wintype, op); 1247. #endif 1248. return; 1249. } else if (negated) bad_negation(fullname, TRUE); 1250. return; 1251. } 1252. #ifdef CHANGE_COLOR 1253. if (match_optname(opts, "palette", 3, TRUE) 1254. # ifdef MAC 1255. || match_optname(opts, "hicolor", 3, TRUE) 1256. # endif 1257. ) { 1258. int color_number, color_incr; 1259. 1260. # ifdef MAC 1261. if (match_optname(opts, "hicolor", 3, TRUE)) { 1262. if (negated) { 1263. bad_negation("hicolor", FALSE); 1264. return; 1265. } 1266. color_number = CLR_MAX + 4; /* HARDCODED inverse number */ 1267. color_incr = -1; 1268. } else { 1269. # endif 1270. if (negated) { 1271. bad_negation("palette", FALSE); 1272. return; 1273. } 1274. color_number = 0; 1275. color_incr = 1; 1276. # ifdef MAC 1277. } 1278. # endif 1279. if ((op = string_for_opt(opts, FALSE)) != (char *)0) { 1280. char *pt = op; 1281. int cnt, tmp, reverse; 1282. long rgb; 1283. 1284. while (*pt && color_number >= 0) { 1285. cnt = 3; 1286. rgb = 0L; 1287. if (*pt == '-') { 1288. reverse = 1; 1289. pt++; 1290. } else { 1291. reverse = 0; 1292. } 1293. while (cnt-- > 0) { 1294. if (*pt && *pt != '/') { 1295. # ifdef AMIGA 1296. rgb <<= 4; 1297. # else 1298. rgb <<= 8; 1299. # endif 1300. tmp = *(pt++); 1301. if (isalpha(tmp)) { 1302. tmp = (tmp + 9) & 0xf; /* Assumes ASCII... */ 1303. } else { 1304. tmp &= 0xf; /* Digits in ASCII too... */ 1305. } 1306. # ifndef AMIGA 1307. /* Add an extra so we fill f -> ff and 0 -> 00 */ 1308. rgb += tmp << 4; 1309. # endif 1310. rgb += tmp; 1311. } 1312. } 1313. if (*pt == '/') { 1314. pt++; 1315. } 1316. change_color(color_number, rgb, reverse); 1317. color_number += color_incr; 1318. } 1319. } 1320. if (!initial) { 1321. need_redraw = TRUE; 1322. } 1323. return; 1324. } 1325. #endif /* CHANGE_COLOR */ 1326. 1327. if (match_optname(opts, "fruit", 2, TRUE)) { 1328. char empty_str = '\0'; 1329. op = string_for_opt(opts, negated); 1330. if (negated) { 1331. if (op) { 1332. bad_negation("fruit", TRUE); 1333. return; 1334. } 1335. op = &empty_str; 1336. goto goodfruit; 1337. } 1338. if (!op) return; 1339. if (!initial) { 1340. struct fruit *f; 1341. 1342. num = 0; 1343. for(f=ffruit; f; f=f->nextf) { 1344. if (!strcmp(op, f->fname)) goto goodfruit; 1345. num++; 1346. } 1347. if (num >= 100) { 1348. pline("Doing that so many times isn't very fruitful."); 1349. return; 1350. } 1351. } 1352. goodfruit: 1353. nmcpy(pl_fruit, op, PL_FSIZ); 1354. /* OBJ_NAME(objects[SLIME_MOLD]) won't work after initialization */ 1355. if (!*pl_fruit) 1356. nmcpy(pl_fruit, "slime mold", PL_FSIZ); 1357. if (!initial) 1358. (void)fruitadd(pl_fruit); 1359. /* If initial, then initoptions is allowed to do it instead 1360. * of here (initoptions always has to do it even if there's 1361. * no fruit option at all. Also, we don't want people 1362. * setting multiple fruits in their options.) 1363. */ 1364. return; 1365. } 1366. 1367. /* graphics:string */ 1368. fullname = "graphics"; 1369. if (match_optname(opts, fullname, 2, TRUE)) { 1370. if (negated) bad_negation(fullname, FALSE); 1371. else graphics_opts(opts, fullname, MAXPCHARS, 0); 1372. return; 1373. } 1374. fullname = "dungeon"; 1375. if (match_optname(opts, fullname, 2, TRUE)) { 1376. if (negated) bad_negation(fullname, FALSE); 1377. else graphics_opts(opts, fullname, MAXDCHARS, 0); 1378. return; 1379. } 1380. fullname = "traps"; 1381. if (match_optname(opts, fullname, 2, TRUE)) { 1382. if (negated) bad_negation(fullname, FALSE); 1383. else graphics_opts(opts, fullname, MAXTCHARS, MAXDCHARS); 1384. return; 1385. } 1386. fullname = "effects"; 1387. if (match_optname(opts, fullname, 2, TRUE)) { 1388. if (negated) bad_negation(fullname, FALSE); 1389. else 1390. graphics_opts(opts, fullname, MAXECHARS, MAXDCHARS+MAXTCHARS); 1391. return; 1392. } 1393. 1394. /* objects:string */ 1395. fullname = "objects"; 1396. if (match_optname(opts, fullname, 7, TRUE)) { 1397. int length; 1398. 1399. if (negated) { 1400. bad_negation(fullname, FALSE); 1401. return; 1402. } 1403. if (!(opts = string_for_env_opt(fullname, opts, FALSE))) 1404. return; 1405. escapes(opts, opts); 1406. 1407. /* 1408. * Override the default object class symbols. The first 1409. * object in the object class is the "random object". I 1410. * don't want to use 0 as an object class, so the "random 1411. * object" is basically a place holder. 1412. * 1413. * The object class symbols have already been initialized in 1414. * initoptions(). 1415. */ 1416. length = strlen(opts); 1417. if (length >= MAXOCLASSES) 1418. length = MAXOCLASSES-1; /* don't count RANDOM_OBJECT */ 1419. 1420. for (i = 0; i < length; i++) 1421. oc_syms[i+1] = (uchar) opts[i]; 1422. return; 1423. } 1424. 1425. /* monsters:string */ 1426. fullname = "monsters"; 1427. if (match_optname(opts, fullname, 8, TRUE)) { 1428. int length; 1429. 1430. if (negated) { 1431. bad_negation(fullname, FALSE); 1432. return; 1433. } 1434. if (!(opts = string_for_env_opt(fullname, opts, FALSE))) 1435. return; 1436. escapes(opts, opts); 1437. 1438. /* Override default mon class symbols set in initoptions(). */ 1439. length = strlen(opts); 1440. if (length >= MAXMCLASSES) 1441. length = MAXMCLASSES-1; /* mon class 0 unused */ 1442. 1443. for (i = 0; i < length; i++) 1444. monsyms[i+1] = (uchar) opts[i]; 1445. return; 1446. } 1447. fullname = "warnings"; 1448. if (match_optname(opts, fullname, 5, TRUE)) { 1449. if (negated) bad_negation(fullname, FALSE); 1450. else warning_opts(opts, fullname); 1451. return; 1452. } 1453. /* boulder:symbol */ 1454. fullname = "boulder"; 1455. if (match_optname(opts, fullname, 7, TRUE)) { 1456. int clash = 0; 1457. if (negated) { 1458. bad_negation(fullname, FALSE); 1459. return; 1460. } 1461. /* if (!(opts = string_for_env_opt(fullname, opts, FALSE))) */ 1462. if (!(opts = string_for_opt(opts, FALSE))) 1463. return; 1464. escapes(opts, opts); 1465. if (def_char_to_monclass(opts[0]) != MAXMCLASSES) 1466. clash = 1; 1467. else if (opts[0] >= '1' && opts[0] <= '5') 1468. clash = 2; 1469. if (clash) { 1470. /* symbol chosen matches a used monster or warning 1471. symbol which is not good - reject it*/ 1472. pline( 1473. "Badoption - boulder symbol '%c' conflicts with a %s symbol.", 1474. opts[0], (clash == 1) ? "monster" : "warning"); 1475. } else { 1476. /* 1477. * Override the default boulder symbol. 1478. */ 1479. iflags.bouldersym = (uchar) opts[0]; 1480. } 1481. if (!initial) need_redraw = TRUE; 1482. return; 1483. } 1484. 1485. /* name:string */ 1486. fullname = "name"; 1487. if (match_optname(opts, fullname, 4, TRUE)) { 1488. if (negated) bad_negation(fullname, FALSE); 1489. else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) 1490. nmcpy(plname, op, PL_NSIZ); 1491. return; 1492. } 1493. 1494. /* role:string or character:string */ 1495. fullname = "role"; 1496. if (match_optname(opts, fullname, 4, TRUE) || 1497. match_optname(opts, (fullname = "character"), 4, TRUE)) { 1498. if (negated) bad_negation(fullname, FALSE); 1499. else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) { 1500. if ((flags.initrole = str2role(op)) == ROLE_NONE) 1501. badoption(opts); 1502. else /* Backwards compatibility */ 1503. nmcpy(pl_character, op, PL_NSIZ); 1504. } 1505. return; 1506. } 1507. 1508. /* race:string */ 1509. fullname = "race"; 1510. if (match_optname(opts, fullname, 4, TRUE)) { 1511. if (negated) bad_negation(fullname, FALSE); 1512. else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) { 1513. if ((flags.initrace = str2race(op)) == ROLE_NONE) 1514. badoption(opts); 1515. else /* Backwards compatibility */ 1516. pl_race = *op; 1517. } 1518. return; 1519. } 1520. 1521. /* gender:string */ 1522. fullname = "gender"; 1523. if (match_optname(opts, fullname, 4, TRUE)) { 1524. if (negated) bad_negation(fullname, FALSE); 1525. else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) { 1526. if ((flags.initgend = str2gend(op)) == ROLE_NONE) 1527. badoption(opts); 1528. else 1529. flags.female = flags.initgend; 1530. } 1531. return; 1532. } 1533. 1534. /* altkeyhandler:string */ 1535. fullname = "altkeyhandler"; 1536. if (match_optname(opts, fullname, 4, TRUE)) { 1537. if (negated) bad_negation(fullname, FALSE); 1538. else if ((op = string_for_opt(opts, negated))) { 1539. #ifdef WIN32CON 1540. (void)strncpy(iflags.altkeyhandler, op, MAX_ALTKEYHANDLER - 5); 1541. load_keyboard_handler(); 1542. #endif 1543. } 1544. return; 1545. } 1546. 1547. /* WINCAP 1548. * align_status:[left|top|right|bottom] */ 1549. fullname = "align_status"; 1550. if (match_optname(opts, fullname, sizeof("align_status")-1, TRUE)) { 1551. op = string_for_opt(opts, negated); 1552. if (op && !negated) { 1553. if (!strncmpi (op, "left", sizeof("left")-1)) 1554. iflags.wc_align_status = ALIGN_LEFT; 1555. else if (!strncmpi (op, "top", sizeof("top")-1)) 1556. iflags.wc_align_status = ALIGN_TOP; 1557. else if (!strncmpi (op, "right", sizeof("right")-1)) 1558. iflags.wc_align_status = ALIGN_RIGHT; 1559. else if (!strncmpi (op, "bottom", sizeof("bottom")-1)) 1560. iflags.wc_align_status = ALIGN_BOTTOM; 1561. else 1562. badoption(opts); 1563. } else if (negated) bad_negation(fullname, TRUE); 1564. return; 1565. } 1566. /* WINCAP 1567. * align_message:[left|top|right|bottom] */ 1568. fullname = "align_message"; 1569. if (match_optname(opts, fullname, sizeof("align_message")-1, TRUE)) { 1570. op = string_for_opt(opts, negated); 1571. if (op && !negated) { 1572. if (!strncmpi (op, "left", sizeof("left")-1)) 1573. iflags.wc_align_message = ALIGN_LEFT; 1574. else if (!strncmpi (op, "top", sizeof("top")-1)) 1575. iflags.wc_align_message = ALIGN_TOP; 1576. else if (!strncmpi (op, "right", sizeof("right")-1)) 1577. iflags.wc_align_message = ALIGN_RIGHT; 1578. else if (!strncmpi (op, "bottom", sizeof("bottom")-1)) 1579. iflags.wc_align_message = ALIGN_BOTTOM; 1580. else 1581. badoption(opts); 1582. } else if (negated) bad_negation(fullname, TRUE); 1583. return; 1584. } 1585. /* align:string */ 1586. fullname = "align"; 1587. if (match_optname(opts, fullname, sizeof("align")-1, TRUE)) { 1588. if (negated) bad_negation(fullname, FALSE); 1589. else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) 1590. if ((flags.initalign = str2align(op)) == ROLE_NONE) 1591. badoption(opts); 1592. return; 1593. } 1594. 1595. /* the order to list the pack */ 1596. fullname = "packorder"; 1597. if (match_optname(opts, fullname, 4, TRUE)) { 1598. if (negated) { 1599. bad_negation(fullname, FALSE); 1600. return; 1601. } else if (!(op = string_for_opt(opts, FALSE))) return; 1602. 1603. if (!change_inv_order(op)) 1604. badoption(opts); 1605. return; 1606. } 1607. 1608. /* maximum burden picked up before prompt (Warren Cheung) */ 1609. fullname = "pickup_burden"; 1610. if (match_optname(opts, fullname, 8, TRUE)) { 1611. if (negated) { 1612. bad_negation(fullname, FALSE); 1613. return; 1614. } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) { 1615. switch (tolower(*op)) { 1616. /* Unencumbered */ 1617. case 'u': 1618. flags.pickup_burden = UNENCUMBERED; 1619. break; 1620. /* Burdened (slight encumbrance) */ 1621. case 'b': 1622. flags.pickup_burden = SLT_ENCUMBER; 1623. break; 1624. /* streSsed (moderate encumbrance) */ 1625. case 's': 1626. flags.pickup_burden = MOD_ENCUMBER; 1627. break; 1628. /* straiNed (heavy encumbrance) */ 1629. case 'n': 1630. flags.pickup_burden = HVY_ENCUMBER; 1631. break; 1632. /* OverTaxed (extreme encumbrance) */ 1633. case 'o': 1634. case 't': 1635. flags.pickup_burden = EXT_ENCUMBER; 1636. break; 1637. /* overLoaded */ 1638. case 'l': 1639. flags.pickup_burden = OVERLOADED; 1640. break; 1641. default: 1642. badoption(opts); 1643. } 1644. } 1645. return; 1646. } 1647. 1648. /* types of objects to pick up automatically */ 1649. if (match_optname(opts, "pickup_types", 8, TRUE)) { 1650. char ocl[MAXOCLASSES + 1], tbuf[MAXOCLASSES + 1], 1651. qbuf[QBUFSZ], abuf[BUFSZ]; 1652. int oc_sym; 1653. boolean badopt = FALSE, compat = (strlen(opts) <= 6), use_menu; 1654. 1655. oc_to_str(flags.pickup_types, tbuf); 1656. flags.pickup_types[0] = '\0'; /* all */ 1657. op = string_for_opt(opts, (compat || !initial)); 1658. if (!op) { 1659. if (compat || negated || initial) { 1660. /* for backwards compatibility, "pickup" without a 1661. value is a synonym for autopickup of all types 1662. (and during initialization, we can't prompt yet) */ 1663. flags.pickup = !negated; 1664. return; 1665. } 1666. oc_to_str(flags.inv_order, ocl); 1667. use_menu = TRUE; 1668. if (flags.menu_style == MENU_TRADITIONAL || 1669. flags.menu_style == MENU_COMBINATION) { 1670. use_menu = FALSE; 1671. Sprintf(qbuf, "New pickup_types: [%s am] (%s)", 1672. ocl, *tbuf ? tbuf : "all"); 1673. getlin(qbuf, abuf); 1674. op = mungspaces(abuf); 1675. if (abuf[0] == '\0' || abuf[0] == '\033') 1676. op = tbuf; /* restore */ 1677. else if (abuf[0] == 'm') 1678. use_menu = TRUE; 1679. } 1680. if (use_menu) { 1681. (void) choose_classes_menu("Auto-Pickup what?", 1, 1682. TRUE, ocl, tbuf); 1683. op = tbuf; 1684. } 1685. } 1686. if (negated) { 1687. bad_negation("pickup_types", TRUE); 1688. return; 1689. } 1690. while (*op == ' ') op++; 1691. if (*op != 'a' && *op != 'A') { 1692. num = 0; 1693. while (*op) { 1694. oc_sym = def_char_to_objclass(*op); 1695. /* make sure all are valid obj symbols occuring once */ 1696. if (oc_sym != MAXOCLASSES && 1697. !index(flags.pickup_types, oc_sym)) { 1698. flags.pickup_types[num] = (char)oc_sym; 1699. flags.pickup_types[++num] = '\0'; 1700. } else 1701. badopt = TRUE; 1702. op++; 1703. } 1704. if (badopt) badoption(opts); 1705. } 1706. return; 1707. } 1708. /* WINCAP 1709. * player_selection: dialog | prompts */ 1710. fullname = "player_selection"; 1711. if (match_optname(opts, fullname, sizeof("player_selection")-1, TRUE)) { 1712. op = string_for_opt(opts, negated); 1713. if (op && !negated) { 1714. if (!strncmpi (op, "dialog", sizeof("dialog")-1)) 1715. iflags.wc_player_selection = VIA_DIALOG; 1716. else if (!strncmpi (op, "prompt", sizeof("prompt")-1)) 1717. iflags.wc_player_selection = VIA_PROMPTS; 1718. else 1719. badoption(opts); 1720. } else if (negated) bad_negation(fullname, TRUE); 1721. return; 1722. } 1723. 1724. /* things to disclose at end of game */ 1725. if (match_optname(opts, "disclose", 7, TRUE)) { 1726. /* 1727. * The order that the end_disclore options are stored: 1728. * inventory, attribs, vanquished, genocided, conduct 1729. * There is an array in flags: 1730. * end_disclose[NUM_DISCLOSURE_OPT]; 1731. * with option settings for the each of the following: 1732. * iagvc [see disclosure_options in decl.c]: 1733. * Legal setting values in that array are: 1734. * DISCLOSE_PROMPT_DEFAULT_YES ask with default answer yes 1735. * DISCLOSE_PROMPT_DEFAULT_NO ask with default answer no 1736. * DISCLOSE_YES_WITHOUT_PROMPT always disclose and don't ask 1737. * DISCLOSE_NO_WITHOUT_PROMPT never disclose and don't ask 1738. * 1739. * Those setting values can be used in the option 1740. * string as a prefix to get the desired behaviour. 1741. * 1742. * For backward compatibility, no prefix is required, 1743. * and the presence of a i,a,g,v, or c without a prefix 1744. * sets the corresponding value to DISCLOSE_YES_WITHOUT_PROMPT. 1745. */ 1746. boolean badopt = FALSE; 1747. int idx, prefix_val; 1748. 1749. op = string_for_opt(opts, TRUE); 1750. if (op && negated) { 1751. bad_negation("disclose", TRUE); 1752. return; 1753. } 1754. /* "disclose" without a value means "all with prompting" 1755. and negated means "none without prompting" */ 1756. if (!op || !strcmpi(op, "all") || !strcmpi(op, "none")) { 1757. if (op && !strcmpi(op, "none")) negated = TRUE; 1758. for (num = 0; num < NUM_DISCLOSURE_OPTIONS; num++) 1759. flags.end_disclose[num] = negated ? 1760. DISCLOSE_NO_WITHOUT_PROMPT : 1761. DISCLOSE_PROMPT_DEFAULT_YES; 1762. return; 1763. } 1764. 1765. num = 0; 1766. prefix_val = -1; 1767. while (*op && num < sizeof flags.end_disclose - 1) { 1768. register char c, *dop; 1769. static char valid_settings[] = { 1770. DISCLOSE_PROMPT_DEFAULT_YES, 1771. DISCLOSE_PROMPT_DEFAULT_NO, 1772. DISCLOSE_YES_WITHOUT_PROMPT, 1773. DISCLOSE_NO_WITHOUT_PROMPT, 1774. '\0' 1775. }; 1776. c = lowc(*op); 1777. if (c == 'k') c = 'v'; /* killed -> vanquished */ 1778. dop = index(disclosure_options, c); 1779. if (dop) { 1780. idx = dop - disclosure_options; 1781. if (idx < 0 || idx > NUM_DISCLOSURE_OPTIONS - 1) { 1782. impossible("bad disclosure index %d %c", 1783. idx, c); 1784. continue; 1785. } 1786. if (prefix_val != -1) { 1787. flags.end_disclose[idx] = prefix_val; 1788. prefix_val = -1; 1789. } else 1790. flags.end_disclose[idx] = DISCLOSE_YES_WITHOUT_PROMPT; 1791. } else if (index(valid_settings, c)) { 1792. prefix_val = c; 1793. } else if (c == ' ') { 1794. /* do nothing */ 1795. } else 1796. badopt = TRUE; 1797. op++; 1798. } 1799. if (badopt) badoption(opts); 1800. return; 1801. } 1802. 1803. /* scores:5t[op] 5a[round] o[wn] */ 1804. if (match_optname(opts, "scores", 4, TRUE)) { 1805. if (negated) { 1806. bad_negation("scores", FALSE); 1807. return; 1808. } 1809. if (!(op = string_for_opt(opts, FALSE))) return; 1810. 1811. while (*op) { 1812. int inum = 1; 1813. 1814. if (digit(*op)) { 1815. inum = atoi(op); 1816. while (digit(*op)) op++; 1817. } else if (*op == '!') { 1818. negated = !negated; 1819. op++; 1820. } 1821. while (*op == ' ') op++; 1822. 1823. switch (*op) { 1824. case 't': 1825. case 'T': flags.end_top = inum; 1826. break; 1827. case 'a': 1828. case 'A': flags.end_around = inum; 1829. break; 1830. case 'o': 1831. case 'O': flags.end_own = !negated; 1832. break; 1833. default: badoption(opts); 1834. return; 1835. } 1836. while (letter(*++op) || *op == ' ') continue; 1837. if (*op == '/') op++; 1838. } 1839. return; 1840. } 1841. 1842. fullname = "suppress_alert"; 1843. if (match_optname(opts, fullname, 4, TRUE)) { 1844. op = string_for_opt(opts, negated); 1845. if (negated) bad_negation(fullname, FALSE); 1846. else if (op) (void) feature_alert_opts(op,fullname); 1847. return; 1848. } 1849. 1850. #ifdef VIDEOSHADES 1851. /* videocolors:string */ 1852. fullname = "videocolors"; 1853. if (match_optname(opts, fullname, 6, TRUE) || 1854. match_optname(opts, "videocolours", 10, TRUE)) { 1855. if (negated) { 1856. bad_negation(fullname, FALSE); 1857. return; 1858. } 1859. else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) { 1860. return; 1861. } 1862. if (!assign_videocolors(opts)) 1863. badoption(opts); 1864. return; 1865. } 1866. /* videoshades:string */ 1867. fullname = "videoshades"; 1868. if (match_optname(opts, fullname, 6, TRUE)) { 1869. if (negated) { 1870. bad_negation(fullname, FALSE); 1871. return; 1872. } 1873. else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) { 1874. return; 1875. } 1876. if (!assign_videoshades(opts)) 1877. badoption(opts); 1878. return; 1879. } 1880. #endif /* VIDEOSHADES */ 1881. #ifdef MSDOS 1882. # ifdef NO_TERMS 1883. /* video:string -- must be after longer tests */ 1884. fullname = "video"; 1885. if (match_optname(opts, fullname, 5, TRUE)) { 1886. if (negated) { 1887. bad_negation(fullname, FALSE); 1888. return; 1889. } 1890. else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) { 1891. return; 1892. } 1893. if (!assign_video(opts)) 1894. badoption(opts); 1895. return; 1896. } 1897. # endif /* NO_TERMS */ 1898. /* soundcard:string -- careful not to match boolean 'sound' */ 1899. fullname = "soundcard"; 1900. if (match_optname(opts, fullname, 6, TRUE)) { 1901. if (negated) { 1902. bad_negation(fullname, FALSE); 1903. return; 1904. } 1905. else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) { 1906. return; 1907. } 1908. if (!assign_soundcard(opts)) 1909. badoption(opts); 1910. return; 1911. } 1912. #endif /* MSDOS */ 1913. 1914. /* WINCAP 1915. * map_mode:[tiles|ascii4x6|ascii6x8|ascii8x8|ascii16x8|ascii7x12|ascii8x12| 1916. ascii16x12|ascii12x16|ascii10x18|fit_to_screen] */ 1917. fullname = "map_mode"; 1918. if (match_optname(opts, fullname, sizeof("map_mode")-1, TRUE)) { 1919. op = string_for_opt(opts, negated); 1920. if (op && !negated) { 1921. if (!strncmpi (op, "tiles", sizeof("tiles")-1)) 1922. iflags.wc_map_mode = MAP_MODE_TILES; 1923. else if (!strncmpi (op, "ascii4x6", sizeof("ascii4x6")-1)) 1924. iflags.wc_map_mode = MAP_MODE_ASCII4x6; 1925. else if (!strncmpi (op, "ascii6x8", sizeof("ascii6x8")-1)) 1926. iflags.wc_map_mode = MAP_MODE_ASCII6x8; 1927. else if (!strncmpi (op, "ascii8x8", sizeof("ascii8x8")-1)) 1928. iflags.wc_map_mode = MAP_MODE_ASCII8x8; 1929. else if (!strncmpi (op, "ascii16x8", sizeof("ascii16x8")-1)) 1930. iflags.wc_map_mode = MAP_MODE_ASCII16x8; 1931. else if (!strncmpi (op, "ascii7x12", sizeof("ascii7x12")-1)) 1932. iflags.wc_map_mode = MAP_MODE_ASCII7x12; 1933. else if (!strncmpi (op, "ascii8x12", sizeof("ascii8x12")-1)) 1934. iflags.wc_map_mode = MAP_MODE_ASCII8x12; 1935. else if (!strncmpi (op, "ascii16x12", sizeof("ascii16x12")-1)) 1936. iflags.wc_map_mode = MAP_MODE_ASCII16x12; 1937. else if (!strncmpi (op, "ascii12x16", sizeof("ascii12x16")-1)) 1938. iflags.wc_map_mode = MAP_MODE_ASCII12x16; 1939. else if (!strncmpi (op, "ascii10x18", sizeof("ascii10x18")-1)) 1940. iflags.wc_map_mode = MAP_MODE_ASCII10x18; 1941. else if (!strncmpi (op, "fit_to_screen", sizeof("fit_to_screen")-1)) 1942. iflags.wc_map_mode = MAP_MODE_ASCII_FIT_TO_SCREEN; 1943. else 1944. badoption(opts); 1945. } else if (negated) bad_negation(fullname, TRUE); 1946. return; 1947. } 1948. /* WINCAP 1949. * scroll_amount:nn */ 1950. fullname = "scroll_amount"; 1951. if (match_optname(opts, fullname, sizeof("scroll_amount")-1, TRUE)) { 1952. op = string_for_opt(opts, negated); 1953. if ((negated && !op) || (!negated && op)) { 1954. iflags.wc_scroll_amount = negated ? 1 : atoi(op); 1955. } else if (negated) bad_negation(fullname, TRUE); 1956. return; 1957. } 1958. /* WINCAP 1959. * scroll_margin:nn */ 1960. fullname = "scroll_margin"; 1961. if (match_optname(opts, fullname, sizeof("scroll_margin")-1, TRUE)) { 1962. op = string_for_opt(opts, negated); 1963. if ((negated && !op) || (!negated && op)) { 1964. iflags.wc_scroll_margin = negated ? 5 : atoi(op); 1965. } else if (negated) bad_negation(fullname, TRUE); 1966. return; 1967. } 1968. fullname = "subkeyvalue"; 1969. if (match_optname(opts, fullname, 5, TRUE)) { 1970. if (negated) bad_negation(fullname, FALSE); 1971. else { 1972. #if defined(WIN32CON) 1973. op = string_for_opt(opts, 0); 1974. map_subkeyvalue(op); 1975. #endif 1976. } 1977. return; 1978. } 1979. /* WINCAP 1980. * tile_width:nn */ 1981. fullname = "tile_width"; 1982. if (match_optname(opts, fullname, sizeof("tile_width")-1, TRUE)) { 1983. op = string_for_opt(opts, negated); 1984. if ((negated && !op) || (!negated && op)) { 1985. iflags.wc_tile_width = negated ? 0 : atoi(op); 1986. } else if (negated) bad_negation(fullname, TRUE); 1987. return; 1988. } 1989. /* WINCAP 1990. * tile_file:name */ 1991. fullname = "tile_file"; 1992. if (match_optname(opts, fullname, sizeof("tile_file")-1, TRUE)) { 1993. if ((op = string_for_opt(opts, FALSE)) != 0) { 1994. if (iflags.wc_tile_file) free(iflags.wc_tile_file); 1995. iflags.wc_tile_file = (char *)alloc(strlen(op) + 1); 1996. Strcpy(iflags.wc_tile_file, op); 1997. } 1998. return; 1999. } 2000. /* WINCAP 2001. * tile_height:nn */ 2002. fullname = "tile_height"; 2003. if (match_optname(opts, fullname, sizeof("tile_height")-1, TRUE)) { 2004. op = string_for_opt(opts, negated); 2005. if ((negated && !op) || (!negated && op)) { 2006. iflags.wc_tile_height = negated ? 0 : atoi(op); 2007. } else if (negated) bad_negation(fullname, TRUE); 2008. return; 2009. } 2010. /* WINCAP 2011. * vary_msgcount:nn */ 2012. fullname = "vary_msgcount"; 2013. if (match_optname(opts, fullname, sizeof("vary_msgcount")-1, TRUE)) { 2014. op = string_for_opt(opts, negated); 2015. if ((negated && !op) || (!negated && op)) { 2016. iflags.wc_vary_msgcount = negated ? 0 : atoi(op); 2017. } else if (negated) bad_negation(fullname, TRUE); 2018. return; 2019. } 2020. fullname = "windowtype"; 2021. if (match_optname(opts, fullname, 3, TRUE)) { 2022. if (negated) { 2023. bad_negation(fullname, FALSE); 2024. return; 2025. } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) { 2026. char buf[WINTYPELEN]; 2027. nmcpy(buf, op, WINTYPELEN); 2028. choose_windows(buf); 2029. } 2030. return; 2031. } 2032. 2033. /* WINCAP 2034. * setting window colors 2035. * syntax: windowcolors=menu foregrnd/backgrnd text foregrnd/backgrnd 2036. */ 2037. fullname = "windowcolors"; 2038. if (match_optname(opts, fullname, 7, TRUE)) { 2039. if ((op = string_for_opt(opts, FALSE)) != 0) { 2040. if (!wc_set_window_colors(op)) 2041. badoption(opts); 2042. } else if (negated) bad_negation(fullname, TRUE); 2043. return; 2044. } 2045. 2046. /* menustyle:traditional or combo or full or partial */ 2047. if (match_optname(opts, "menustyle", 4, TRUE)) { 2048. int tmp; 2049. boolean val_required = (strlen(opts) > 5 && !negated); 2050. 2051. if (!(op = string_for_opt(opts, !val_required))) { 2052. if (val_required) return; /* string_for_opt gave feedback */ 2053. tmp = negated ? 'n' : 'f'; 2054. } else { 2055. tmp = tolower(*op); 2056. } 2057. switch (tmp) { 2058. case 'n': /* none */ 2059. case 't': /* traditional */ 2060. flags.menu_style = MENU_TRADITIONAL; 2061. break; 2062. case 'c': /* combo: trad.class sel+menu */ 2063. flags.menu_style = MENU_COMBINATION; 2064. break; 2065. case 'p': /* partial: no class menu */ 2066. flags.menu_style = MENU_PARTIAL; 2067. break; 2068. case 'f': /* full: class menu + menu */ 2069. flags.menu_style = MENU_FULL; 2070. break; 2071. default: 2072. badoption(opts); 2073. } 2074. return; 2075. } 2076. 2077. fullname = "menu_headings"; 2078. if (match_optname(opts, fullname, 12, TRUE)) { 2079. if (negated) { 2080. bad_negation(fullname, FALSE); 2081. return; 2082. } 2083. else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) { 2084. return; 2085. } 2086. if (!strcmpi(opts,"bold")) 2087. iflags.menu_headings = ATR_BOLD; 2088. else if (!strcmpi(opts,"inverse")) 2089. iflags.menu_headings = ATR_INVERSE; 2090. else if (!strcmpi(opts,"underline")) 2091. iflags.menu_headings = ATR_ULINE; 2092. else 2093. badoption(opts); 2094. return; 2095. } 2096. 2097. /* check for menu command mapping */ 2098. for (i = 0; i < NUM_MENU_CMDS; i++) { 2099. fullname = default_menu_cmd_info[i].name; 2100. if (match_optname(opts, fullname, (int)strlen(fullname), TRUE)) { 2101. if (negated) 2102. bad_negation(fullname, FALSE); 2103. else if ((op = string_for_opt(opts, FALSE)) != 0) { 2104. int j; 2105. char c, op_buf[BUFSZ]; 2106. boolean isbad = FALSE; 2107. 2108. escapes(op, op_buf); 2109. c = *op_buf; 2110. 2111. if (c == 0 || c == '\r' || c == '\n' || c == '\033' || 2112. c == ' ' || digit(c) || (letter(c) && c != '@')) 2113. isbad = TRUE; 2114. else /* reject default object class symbols */ 2115. for (j = 1; j < MAXOCLASSES; j++) 2116. if (c == def_oc_syms[i]) { 2117. isbad = TRUE; 2118. break; 2119. } 2120. 2121. if (isbad) 2122. badoption(opts); 2123. else 2124. add_menu_cmd_alias(c, default_menu_cmd_info[i].cmd); 2125. } 2126. return; 2127. } 2128. } 2129. 2130. /* OK, if we still haven't recognized the option, check the boolean 2131. * options list 2132. */ 2133. for (i = 0; boolopt[i].name; i++) { 2134. if (match_optname(opts, boolopt[i].name, 3, FALSE)) { 2135. /* options that don't exist */ 2136. if (!boolopt[i].addr) { 2137. if (!initial && !negated) 2138. pline_The("\"%s\" option is not available.", 2139. boolopt[i].name); 2140. return; 2141. } 2142. /* options that must come from config file */ 2143. if (!initial && (boolopt[i].optflags == SET_IN_FILE)) { 2144. rejectoption(boolopt[i].name); 2145. return; 2146. } 2147. 2148. *(boolopt[i].addr) = !negated; 2149. 2150. duplicate_opt_detection(boolopt[i].name, 0); 2151. 2152. #if defined(TERMLIB) || defined(ASCIIGRAPH) || defined(MAC_GRAPHICS_ENV) 2153. if (FALSE 2154. # ifdef TERMLIB 2155. || (boolopt[i].addr) == &iflags.DECgraphics 2156. # endif 2157. # ifdef ASCIIGRAPH 2158. || (boolopt[i].addr) == &iflags.IBMgraphics 2159. # endif 2160. # ifdef MAC_GRAPHICS_ENV 2161. || (boolopt[i].addr) == &iflags.MACgraphics 2162. # endif 2163. ) { 2164. # ifdef REINCARNATION 2165. if (!initial && Is_rogue_level(&u.uz)) 2166. assign_rogue_graphics(FALSE); 2167. # endif 2168. need_redraw = TRUE; 2169. # ifdef TERMLIB 2170. if ((boolopt[i].addr) == &iflags.DECgraphics) 2171. switch_graphics(iflags.DECgraphics ? 2172. DEC_GRAPHICS : ASCII_GRAPHICS); 2173. # endif 2174. # ifdef ASCIIGRAPH 2175. if ((boolopt[i].addr) == &iflags.IBMgraphics) 2176. switch_graphics(iflags.IBMgraphics ? 2177. IBM_GRAPHICS : ASCII_GRAPHICS); 2178. # endif 2179. # ifdef MAC_GRAPHICS_ENV 2180. if ((boolopt[i].addr) == &iflags.MACgraphics) 2181. switch_graphics(iflags.MACgraphics ? 2182. MAC_GRAPHICS : ASCII_GRAPHICS); 2183. # endif 2184. # ifdef REINCARNATION 2185. if (!initial && Is_rogue_level(&u.uz)) 2186. assign_rogue_graphics(TRUE); 2187. # endif 2188. } 2189. #endif /* TERMLIB || ASCIIGRAPH || MAC_GRAPHICS_ENV */ 2190. 2191. /* only do processing below if setting with doset() */ 2192. if (initial) return; 2193. 2194. if ((boolopt[i].addr) == &flags.time 2195. #ifdef EXP_ON_BOTL 2196. || (boolopt[i].addr) == &flags.showexp 2197. #endif 2198. #ifdef SCORE_ON_BOTL 2199. || (boolopt[i].addr) == &flags.showscore 2200. #endif 2201. ) 2202. flags.botl = TRUE; 2203. 2204. else if ((boolopt[i].addr) == &flags.invlet_constant) { 2205. if (flags.invlet_constant) reassign(); 2206. } 2207. #ifdef LAN_MAIL 2208. else if ((boolopt[i].addr) == &flags.biff) { 2209. if (flags.biff) lan_mail_init(); 2210. else lan_mail_finish(); 2211. } 2212. #endif 2213. else if ((boolopt[i].addr) == &flags.lit_corridor) { 2214. /* 2215. * All corridor squares seen via night vision or 2216. * candles & lamps change. Update them by calling 2217. * newsym() on them. Don't do this if we are 2218. * initializing the options --- the vision system 2219. * isn't set up yet. 2220. */ 2221. vision_recalc(2); /* shut down vision */ 2222. vision_full_recalc = 1; /* delayed recalc */ 2223. } 2224. else if ((boolopt[i].addr) == &iflags.use_inverse || 2225. (boolopt[i].addr) == &iflags.showrace || 2226. (boolopt[i].addr) == &iflags.hilite_pet) { 2227. need_redraw = TRUE; 2228. } 2229. #ifdef TEXTCOLOR 2230. else if ((boolopt[i].addr) == &iflags.use_color) { 2231. need_redraw = TRUE; 2232. # ifdef TOS 2233. if ((boolopt[i].addr) == &iflags.use_color 2234. && iflags.BIOS) { 2235. if (colors_changed) 2236. restore_colors(); 2237. else 2238. set_colors(); 2239. } 2240. # endif 2241. } 2242. #endif 2243. 2244. return; 2245. } 2246. } 2247. 2248. /* out of valid options */ 2249. badoption(opts); 2250. } 2251. 2252.
2253. static NEARDATA const char *menutype[] = { 2254. "traditional", "combination", "partial", "full" 2255. }; 2256. 2257. static NEARDATA const char *burdentype[] = { 2258. "unencumbered", "burdened", "stressed", 2259. "strained", "overtaxed", "overloaded" 2260. }; 2261. 2262. static NEARDATA const char *runmodes[] = { 2263. "teleport", "run", "walk", "crawl" 2264. }; 2265.
oc_to_str
2266. /* 2267. * Convert the given string of object classes to a string of default object 2268. * symbols. 2269. */ 2270. STATIC_OVL void 2271. oc_to_str(src,dest) 2272. char *src, *dest; 2273. { 2274. int i; 2275. 2276. while ((i = (int) *src++) != 0) { 2277. if (i < 0 || i >= MAXOCLASSES) 2278. impossible("oc_to_str: illegal object class %d", i); 2279. else 2280. *dest++ = def_oc_syms[i]; 2281. } 2282. *dest = '\0'; 2283. } 2284.
2285. /* 2286. * Add the given mapping to the menu command map list. Always keep the 2287. * maps valid C strings. 2288. */ 2289. void 2290. add_menu_cmd_alias(from_ch, to_ch) 2291. char from_ch, to_ch; 2292. { 2293. if (n_menu_mapped >= MAX_MENU_MAPPED_CMDS) 2294. pline("out of menu map space."); 2295. else { 2296. mapped_menu_cmds[n_menu_mapped] = from_ch; 2297. mapped_menu_op[n_menu_mapped] = to_ch; 2298. n_menu_mapped++; 2299. mapped_menu_cmds[n_menu_mapped] = 0; 2300. mapped_menu_op[n_menu_mapped] = 0; 2301. } 2302. } 2303.
2304. /* 2305. * Map the given character to its corresponding menu command. If it 2306. * doesn't match anything, just return the original. 2307. */ 2308. char 2309. map_menu_cmd(ch) 2310. char ch; 2311. { 2312. char *found = index(mapped_menu_cmds, ch); 2313. if (found) { 2314. int idx = found - mapped_menu_cmds; 2315. ch = mapped_menu_op[idx]; 2316. } 2317. return ch; 2318. } 2319. 2320.
2321. #if defined(MICRO) || defined(MAC) || defined(WIN32) 2322. # define OPTIONS_HEADING "OPTIONS" 2323. #else 2324. # define OPTIONS_HEADING "NETHACKOPTIONS" 2325. #endif 2326. 2327. static char fmtstr_doset_add_menu[] = "%s%-15s [%s] "; 2328. static char fmtstr_doset_add_menu_tab[] = "%s\t[%s]"; 2329. 2330. STATIC_OVL void 2331. doset_add_menu(win, option, indexoffset) 2332. winid win; /* window to add to */ 2333. const char *option; /* option name */ 2334. int indexoffset; /* value to add to index in compopt[], or zero 2335. if option cannot be changed */ 2336. { 2337. const char *value = "unknown"; /* current value */ 2338. char buf[BUFSZ], buf2[BUFSZ]; 2339. anything any; 2340. int i; 2341. 2342. any.a_void = 0; 2343. if (indexoffset == 0) { 2344. any.a_int = 0; 2345. value = get_compopt_value(option, buf2); 2346. } else { 2347. for (i=0; compopt[i].name; i++) 2348. if (strcmp(option, compopt[i].name) == 0) break; 2349. 2350. if (compopt[i].name) { 2351. any.a_int = i + 1 + indexoffset; 2352. value = get_compopt_value(option, buf2); 2353. } else { 2354. /* We are trying to add an option not found in compopt[]. 2355. This is almost certainly bad, but we'll let it through anyway 2356. (with a zero value, so it can't be selected). */ 2357. any.a_int = 0; 2358. } 2359. } 2360. /* " " replaces "a - " -- assumes menus follow that style */ 2361. if (!iflags.menu_tab_sep) 2362. Sprintf(buf, fmtstr_doset_add_menu, any.a_int ? "" : " ", option, value); 2363. else 2364. Sprintf(buf, fmtstr_doset_add_menu_tab, option, value); 2365. add_menu(win, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, MENU_UNSELECTED); 2366. } 2367.
doset
2368. /* Changing options via menu by Per Liboriussen */ 2369. int 2370. doset() 2371. { 2372. char buf[BUFSZ], buf2[BUFSZ]; 2373. int i, pass, boolcount, pick_cnt, pick_idx, opt_indx; 2374. boolean *bool_p; 2375. winid tmpwin; 2376. anything any; 2377. menu_item *pick_list; 2378. int indexoffset, startpass, endpass; 2379. boolean setinitial = FALSE, fromfile = FALSE; 2380. int biggest_name = 0; 2381. 2382. tmpwin = create_nhwindow(NHW_MENU); 2383. start_menu(tmpwin); 2384. 2385. any.a_void = 0; 2386. add_menu(tmpwin, NO_GLYPH, &any, 0, 0, iflags.menu_headings, 2387. "Booleans (selecting will toggle value):", MENU_UNSELECTED); 2388. any.a_int = 0; 2389. /* first list any other non-modifiable booleans, then modifiable ones */ 2390. for (pass = 0; pass <= 1; pass++) 2391. for (i = 0; boolopt[i].name; i++) 2392. if ((bool_p = boolopt[i].addr) != 0 && 2393. ((boolopt[i].optflags == DISP_IN_GAME && pass == 0) || 2394. (boolopt[i].optflags == SET_IN_GAME && pass == 1))) { 2395. if (bool_p == &flags.female) continue; /* obsolete */ 2396. #ifdef WIZARD 2397. if (bool_p == &iflags.sanity_check && !wizard) continue; 2398. if (bool_p == &iflags.menu_tab_sep && !wizard) continue; 2399. #endif 2400. if (is_wc_option(boolopt[i].name) && 2401. !wc_supported(boolopt[i].name)) continue; 2402. if (is_wc2_option(boolopt[i].name) && 2403. !wc2_supported(boolopt[i].name)) continue; 2404. any.a_int = (pass == 0) ? 0 : i + 1; 2405. if (!iflags.menu_tab_sep) 2406. Sprintf(buf, "%s%-13s [%s]", 2407. pass == 0 ? " " : "", 2408. boolopt[i].name, *bool_p ? "true" : "false"); 2409. else 2410. Sprintf(buf, "%s\t[%s]", 2411. boolopt[i].name, *bool_p ? "true" : "false"); 2412. add_menu(tmpwin, NO_GLYPH, &any, 0, 0, 2413. ATR_NONE, buf, MENU_UNSELECTED); 2414. } 2415. 2416. boolcount = i; 2417. indexoffset = boolcount; 2418. any.a_void = 0; 2419. add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, "", MENU_UNSELECTED); 2420. add_menu(tmpwin, NO_GLYPH, &any, 0, 0, iflags.menu_headings, 2421. "Compounds (selecting will prompt for new value):", 2422. MENU_UNSELECTED); 2423. 2424. startpass = DISP_IN_GAME; 2425. endpass = SET_IN_GAME; 2426. 2427. /* spin through the options to find the biggest name 2428. and adjust the format string accordingly if needed */ 2429. biggest_name = 0; 2430. for (i = 0; compopt[i].name; i++) 2431. if (compopt[i].optflags >= startpass && compopt[i].optflags <= endpass && 2432. strlen(compopt[i].name) > (unsigned) biggest_name) 2433. biggest_name = (int) strlen(compopt[i].name); 2434. if (biggest_name > 30) biggest_name = 30; 2435. if (!iflags.menu_tab_sep) 2436. Sprintf(fmtstr_doset_add_menu, "%%s%%-%ds [%%s]", biggest_name); 2437. 2438. /* deliberately put `name', `role', `race', `gender' first */ 2439. doset_add_menu(tmpwin, "name", 0); 2440. doset_add_menu(tmpwin, "role", 0); 2441. doset_add_menu(tmpwin, "race", 0); 2442. doset_add_menu(tmpwin, "gender", 0); 2443. 2444. for (pass = startpass; pass <= endpass; pass++) 2445. for (i = 0; compopt[i].name; i++) 2446. if (compopt[i].optflags == pass) { 2447. if (!strcmp(compopt[i].name, "name") || 2448. !strcmp(compopt[i].name, "role") || 2449. !strcmp(compopt[i].name, "race") || 2450. !strcmp(compopt[i].name, "gender")) 2451. continue; 2452. else if (is_wc_option(compopt[i].name) && 2453. !wc_supported(compopt[i].name)) 2454. continue; 2455. else if (is_wc2_option(compopt[i].name) && 2456. !wc2_supported(compopt[i].name)) 2457. continue; 2458. else 2459. doset_add_menu(tmpwin, compopt[i].name, 2460. (pass == DISP_IN_GAME) ? 0 : indexoffset); 2461. } 2462. #ifdef AUTOPICKUP_EXCEPTIONS 2463. any.a_int = -1; 2464. Sprintf(buf, "autopickup exceptions (%d currently set)", 2465. count_ape_maps((int *)0, (int *)0)); 2466. add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, MENU_UNSELECTED); 2467. 2468. #endif /* AUTOPICKUP_EXCEPTIONS */ 2469. #ifdef PREFIXES_IN_USE 2470. any.a_void = 0; 2471. add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, "", MENU_UNSELECTED); 2472. add_menu(tmpwin, NO_GLYPH, &any, 0, 0, iflags.menu_headings, 2473. "Variable playground locations:", MENU_UNSELECTED); 2474. for (i = 0; i < PREFIX_COUNT; i++) 2475. doset_add_menu(tmpwin, fqn_prefix_names[i], 0); 2476. #endif 2477. end_menu(tmpwin, "Set what options?"); 2478. need_redraw = FALSE; 2479. if ((pick_cnt = select_menu(tmpwin, PICK_ANY, &pick_list)) > 0) { 2480. /* 2481. * Walk down the selection list and either invert the booleans 2482. * or prompt for new values. In most cases, call parseoptions() 2483. * to take care of options that require special attention, like 2484. * redraws. 2485. */ 2486. for (pick_idx = 0; pick_idx < pick_cnt; ++pick_idx) { 2487. opt_indx = pick_list[pick_idx].item.a_int - 1; 2488. #ifdef AUTOPICKUP_EXCEPTIONS 2489. if (opt_indx == -2) { 2490. special_handling("autopickup_exception", 2491. setinitial, fromfile); 2492. } else 2493. #endif 2494. if (opt_indx < boolcount) { 2495. /* boolean option */ 2496. Sprintf(buf, "%s%s", *boolopt[opt_indx].addr ? "!" : "", 2497. boolopt[opt_indx].name); 2498. parseoptions(buf, setinitial, fromfile); 2499. if (wc_supported(boolopt[opt_indx].name) || 2500. wc2_supported(boolopt[opt_indx].name)) 2501. preference_update(boolopt[opt_indx].name); 2502. } else { 2503. /* compound option */ 2504. opt_indx -= boolcount; 2505. 2506. if (!special_handling(compopt[opt_indx].name, 2507. setinitial, fromfile)) { 2508. Sprintf(buf, "Set %s to what?", compopt[opt_indx].name); 2509. getlin(buf, buf2); 2510. if (buf2[0] == '\033') 2511. continue; 2512. Sprintf(buf, "%s:%s", compopt[opt_indx].name, buf2); 2513. /* pass the buck */ 2514. parseoptions(buf, setinitial, fromfile); 2515. } 2516. if (wc_supported(compopt[opt_indx].name) || 2517. wc2_supported(compopt[opt_indx].name)) 2518. preference_update(compopt[opt_indx].name); 2519. } 2520. } 2521. free((genericptr_t)pick_list); 2522. pick_list = (menu_item *)0; 2523. } 2524. 2525. destroy_nhwindow(tmpwin); 2526. if (need_redraw) 2527. (void) doredraw(); 2528. return 0; 2529. } 2530.
special_handling
2531. STATIC_OVL boolean 2532. special_handling(optname, setinitial, setfromfile) 2533. const char *optname; 2534. boolean setinitial,setfromfile; 2535. { 2536. winid tmpwin; 2537. anything any; 2538. int i; 2539. char buf[BUFSZ]; 2540. boolean retval = FALSE; 2541. 2542. /* Special handling of menustyle, pickup_burden, pickup_types, 2543. * disclose, runmode, msg_window, menu_headings, and number_pad options. 2544. #ifdef AUTOPICKUP_EXCEPTIONS 2545. * Also takes care of interactive autopickup_exception_handling changes. 2546. #endif 2547. */ 2548. if (!strcmp("menustyle", optname)) { 2549. const char *style_name; 2550. menu_item *style_pick = (menu_item *)0; 2551. tmpwin = create_nhwindow(NHW_MENU); 2552. start_menu(tmpwin); 2553. for (i = 0; i < SIZE(menutype); i++) { 2554. style_name = menutype[i]; 2555. /* note: separate `style_name' variable used 2556. to avoid an optimizer bug in VAX C V2.3 */ 2557. any.a_int = i + 1; 2558. add_menu(tmpwin, NO_GLYPH, &any, *style_name, 0, 2559. ATR_NONE, style_name, MENU_UNSELECTED); 2560. } 2561. end_menu(tmpwin, "Select menustyle:"); 2562. if (select_menu(tmpwin, PICK_ONE, &style_pick) > 0) { 2563. flags.menu_style = style_pick->item.a_int - 1; 2564. free((genericptr_t)style_pick); 2565. } 2566. destroy_nhwindow(tmpwin); 2567. retval = TRUE; 2568. } else if (!strcmp("pickup_burden", optname)) { 2569. const char *burden_name, *burden_letters = "ubsntl"; 2570. menu_item *burden_pick = (menu_item *)0; 2571. tmpwin = create_nhwindow(NHW_MENU); 2572. start_menu(tmpwin); 2573. for (i = 0; i < SIZE(burdentype); i++) { 2574. burden_name = burdentype[i]; 2575. any.a_int = i + 1; 2576. add_menu(tmpwin, NO_GLYPH, &any, burden_letters[i], 0, 2577. ATR_NONE, burden_name, MENU_UNSELECTED); 2578. } 2579. end_menu(tmpwin, "Select encumbrance level:"); 2580. if (select_menu(tmpwin, PICK_ONE, &burden_pick) > 0) { 2581. flags.pickup_burden = burden_pick->item.a_int - 1; 2582. free((genericptr_t)burden_pick); 2583. } 2584. destroy_nhwindow(tmpwin); 2585. retval = TRUE; 2586. } else if (!strcmp("pickup_types", optname)) { 2587. /* parseoptions will prompt for the list of types */ 2588. parseoptions(strcpy(buf, "pickup_types"), setinitial, setfromfile); 2589. retval = TRUE; 2590. } else if (!strcmp("disclose", optname)) { 2591. int pick_cnt, pick_idx, opt_idx; 2592. menu_item *disclosure_category_pick = (menu_item *)0; 2593. /* 2594. * The order of disclose_names[] 2595. * must correspond to disclosure_options in decl.h 2596. */ 2597. static const char *disclosure_names[] = { 2598. "inventory", "attributes", "vanquished", "genocides", "conduct" 2599. }; 2600. int disc_cat[NUM_DISCLOSURE_OPTIONS]; 2601. const char *disclosure_name; 2602. 2603. tmpwin = create_nhwindow(NHW_MENU); 2604. start_menu(tmpwin); 2605. for (i = 0; i < NUM_DISCLOSURE_OPTIONS; i++) { 2606. disclosure_name = disclosure_names[i]; 2607. any.a_int = i + 1; 2608. add_menu(tmpwin, NO_GLYPH, &any, disclosure_options[i], 0, 2609. ATR_NONE, disclosure_name, MENU_UNSELECTED); 2610. disc_cat[i] = 0; 2611. } 2612. end_menu(tmpwin, "Change which disclosure options categories:"); 2613. if ((pick_cnt = select_menu(tmpwin, PICK_ANY, &disclosure_category_pick)) > 0) { 2614. for (pick_idx = 0; pick_idx < pick_cnt; ++pick_idx) { 2615. opt_idx = disclosure_category_pick[pick_idx].item.a_int - 1; 2616. disc_cat[opt_idx] = 1; 2617. } 2618. free((genericptr_t)disclosure_category_pick); 2619. disclosure_category_pick = (menu_item *)0; 2620. } 2621. destroy_nhwindow(tmpwin); 2622. 2623. for (i = 0; i < NUM_DISCLOSURE_OPTIONS; i++) { 2624. if (disc_cat[i]) { 2625. char dbuf[BUFSZ]; 2626. menu_item *disclosure_option_pick = (menu_item *)0; 2627. Sprintf(dbuf, "Disclosure options for %s:", disclosure_names[i]); 2628. tmpwin = create_nhwindow(NHW_MENU); 2629. start_menu(tmpwin); 2630. any.a_char = DISCLOSE_NO_WITHOUT_PROMPT; 2631. add_menu(tmpwin, NO_GLYPH, &any, 'a', 0, 2632. ATR_NONE,"Never disclose and don't prompt", MENU_UNSELECTED); 2633. any.a_void = 0; 2634. any.a_char = DISCLOSE_YES_WITHOUT_PROMPT; 2635. add_menu(tmpwin, NO_GLYPH, &any, 'b', 0, 2636. ATR_NONE,"Always disclose and don't prompt", MENU_UNSELECTED); 2637. any.a_void = 0; 2638. any.a_char = DISCLOSE_PROMPT_DEFAULT_NO; 2639. add_menu(tmpwin, NO_GLYPH, &any, 'c', 0, 2640. ATR_NONE,"Prompt and default answer to \"No\"", MENU_UNSELECTED); 2641. any.a_void = 0; 2642. any.a_char = DISCLOSE_PROMPT_DEFAULT_YES; 2643. add_menu(tmpwin, NO_GLYPH, &any, 'd', 0, 2644. ATR_NONE,"Prompt and default answer to \"Yes\"", MENU_UNSELECTED); 2645. end_menu(tmpwin, dbuf); 2646. if (select_menu(tmpwin, PICK_ONE, &disclosure_option_pick) > 0) { 2647. flags.end_disclose[i] = disclosure_option_pick->item.a_char; 2648. free((genericptr_t)disclosure_option_pick); 2649. } 2650. destroy_nhwindow(tmpwin); 2651. } 2652. } 2653. retval = TRUE; 2654. } else if (!strcmp("runmode", optname)) { 2655. const char *mode_name; 2656. menu_item *mode_pick = (menu_item *)0; 2657. tmpwin = create_nhwindow(NHW_MENU); 2658. start_menu(tmpwin); 2659. for (i = 0; i < SIZE(runmodes); i++) { 2660. mode_name = runmodes[i]; 2661. any.a_int = i + 1; 2662. add_menu(tmpwin, NO_GLYPH, &any, *mode_name, 0, 2663. ATR_NONE, mode_name, MENU_UNSELECTED); 2664. } 2665. end_menu(tmpwin, "Select run/travel display mode:"); 2666. if (select_menu(tmpwin, PICK_ONE, &mode_pick) > 0) { 2667. iflags.runmode = mode_pick->item.a_int - 1; 2668. free((genericptr_t)mode_pick); 2669. } 2670. destroy_nhwindow(tmpwin); 2671. retval = TRUE; 2672. } 2673. #ifdef TTY_GRAPHICS 2674. else if (!strcmp("msg_window", optname)) { 2675. /* by Christian W. Cooper */ 2676. menu_item *window_pick = (menu_item *)0; 2677. tmpwin = create_nhwindow(NHW_MENU); 2678. start_menu(tmpwin); 2679. any.a_char = 's'; 2680. add_menu(tmpwin, NO_GLYPH, &any, 's', 0, 2681. ATR_NONE, "single", MENU_UNSELECTED); 2682. any.a_char = 'c'; 2683. add_menu(tmpwin, NO_GLYPH, &any, 'c', 0, 2684. ATR_NONE, "combination", MENU_UNSELECTED); 2685. any.a_char = 'f'; 2686. add_menu(tmpwin, NO_GLYPH, &any, 'f', 0, 2687. ATR_NONE, "full", MENU_UNSELECTED); 2688. any.a_char = 'r'; 2689. add_menu(tmpwin, NO_GLYPH, &any, 'r', 0, 2690. ATR_NONE, "reversed", MENU_UNSELECTED); 2691. end_menu(tmpwin, "Select message history display type:"); 2692. if (select_menu(tmpwin, PICK_ONE, &window_pick) > 0) { 2693. iflags.prevmsg_window = window_pick->item.a_char; 2694. free((genericptr_t)window_pick); 2695. } 2696. destroy_nhwindow(tmpwin); 2697. retval = TRUE; 2698. } 2699. #endif 2700. else if (!strcmp("align_message", optname) || 2701. !strcmp("align_status", optname)) { 2702. menu_item *window_pick = (menu_item *)0; 2703. char abuf[BUFSZ]; 2704. boolean msg = (*(optname+6) == 'm'); 2705. 2706. tmpwin = create_nhwindow(NHW_MENU); 2707. start_menu(tmpwin); 2708. any.a_int = ALIGN_TOP; 2709. add_menu(tmpwin, NO_GLYPH, &any, 't', 0, 2710. ATR_NONE, "top", MENU_UNSELECTED); 2711. any.a_int = ALIGN_BOTTOM; 2712. add_menu(tmpwin, NO_GLYPH, &any, 'b', 0, 2713. ATR_NONE, "bottom", MENU_UNSELECTED); 2714. any.a_int = ALIGN_LEFT; 2715. add_menu(tmpwin, NO_GLYPH, &any, 'l', 0, 2716. ATR_NONE, "left", MENU_UNSELECTED); 2717. any.a_int = ALIGN_RIGHT; 2718. add_menu(tmpwin, NO_GLYPH, &any, 'r', 0, 2719. ATR_NONE, "right", MENU_UNSELECTED); 2720. Sprintf(abuf, "Select %s window placement relative to the map:", 2721. msg ? "message" : "status"); 2722. end_menu(tmpwin, abuf); 2723. if (select_menu(tmpwin, PICK_ONE, &window_pick) > 0) { 2724. if (msg) iflags.wc_align_message = window_pick->item.a_int; 2725. else iflags.wc_align_status = window_pick->item.a_int; 2726. free((genericptr_t)window_pick); 2727. } 2728. destroy_nhwindow(tmpwin); 2729. retval = TRUE; 2730. } else if (!strcmp("number_pad", optname)) { 2731. static const char *npchoices[3] = 2732. {"0 (off)", "1 (on)", "2 (on, DOS compatible)"}; 2733. const char *npletters = "abc"; 2734. menu_item *mode_pick = (menu_item *)0; 2735. 2736. tmpwin = create_nhwindow(NHW_MENU); 2737. start_menu(tmpwin); 2738. for (i = 0; i < SIZE(npchoices); i++) { 2739. any.a_int = i + 1; 2740. add_menu(tmpwin, NO_GLYPH, &any, npletters[i], 0, 2741. ATR_NONE, npchoices[i], MENU_UNSELECTED); 2742. } 2743. end_menu(tmpwin, "Select number_pad mode:"); 2744. if (select_menu(tmpwin, PICK_ONE, &mode_pick) > 0) { 2745. int mode = mode_pick->item.a_int - 1; 2746. switch(mode) { 2747. case 2: 2748. iflags.num_pad = 1; 2749. iflags.num_pad_mode = 1; 2750. break; 2751. case 1: 2752. iflags.num_pad = 1; 2753. iflags.num_pad_mode = 0; 2754. break; 2755. case 0: 2756. default: 2757. iflags.num_pad = 0; 2758. iflags.num_pad_mode = 0; 2759. } 2760. free((genericptr_t)mode_pick); 2761. } 2762. destroy_nhwindow(tmpwin); 2763. retval = TRUE; 2764. } else if (!strcmp("menu_headings", optname)) { 2765. static const char *mhchoices[3] = {"bold", "inverse", "underline"}; 2766. const char *npletters = "biu"; 2767. menu_item *mode_pick = (menu_item *)0; 2768. 2769. tmpwin = create_nhwindow(NHW_MENU); 2770. start_menu(tmpwin); 2771. for (i = 0; i < SIZE(mhchoices); i++) { 2772. any.a_int = i + 1; 2773. add_menu(tmpwin, NO_GLYPH, &any, npletters[i], 0, 2774. ATR_NONE, mhchoices[i], MENU_UNSELECTED); 2775. } 2776. end_menu(tmpwin, "How to highlight menu headings:"); 2777. if (select_menu(tmpwin, PICK_ONE, &mode_pick) > 0) { 2778. int mode = mode_pick->item.a_int - 1; 2779. switch(mode) { 2780. case 2: 2781. iflags.menu_headings = ATR_ULINE; 2782. break; 2783. case 0: 2784. iflags.menu_headings = ATR_BOLD; 2785. break; 2786. case 1: 2787. default: 2788. iflags.menu_headings = ATR_INVERSE; 2789. } 2790. free((genericptr_t)mode_pick); 2791. } 2792. destroy_nhwindow(tmpwin); 2793. retval = TRUE; 2794. #ifdef AUTOPICKUP_EXCEPTIONS 2795. } else if (!strcmp("autopickup_exception", optname)) { 2796. boolean retval; 2797. int pick_cnt, pick_idx, opt_idx, pass; 2798. int totalapes = 0, numapes[2] = {0,0}; 2799. menu_item *pick_list = (menu_item *)0; 2800. anything any; 2801. char apebuf[BUFSZ]; 2802. struct autopickup_exception *ape; 2803. static const char *action_titles[] = { 2804. "a", "add new autopickup exception", 2805. "l", "list autopickup exceptions", 2806. "r", "remove existing autopickup exception", 2807. "e", "exit this menu", 2808. }; 2809. ape_again: 2810. opt_idx = 0; 2811. totalapes = count_ape_maps(&numapes[AP_LEAVE], &numapes[AP_GRAB]); 2812. tmpwin = create_nhwindow(NHW_MENU); 2813. start_menu(tmpwin); 2814. any.a_int = 0; 2815. for (i = 0; i < SIZE(action_titles) ; i += 2) { 2816. any.a_int++; 2817. if (!totalapes && (i >= 2 && i < 6)) continue; 2818. add_menu(tmpwin, NO_GLYPH, &any, *action_titles[i], 2819. 0, ATR_NONE, action_titles[i+1], MENU_UNSELECTED); 2820. } 2821. end_menu(tmpwin, "Do what?"); 2822. if ((pick_cnt = select_menu(tmpwin, PICK_ONE, &pick_list)) > 0) { 2823. for (pick_idx = 0; pick_idx < pick_cnt; ++pick_idx) { 2824. opt_idx = pick_list[pick_idx].item.a_int - 1; 2825. } 2826. free((genericptr_t)pick_list); 2827. pick_list = (menu_item *)0; 2828. } 2829. destroy_nhwindow(tmpwin); 2830. if (pick_cnt < 1) return FALSE; 2831. 2832. if (opt_idx == 0) { /* add new */ 2833. getlin("What new autopickup exception pattern?", &apebuf[1]); 2834. if (apebuf[1] == '\033') return FALSE; 2835. apebuf[0] = '"'; 2836. Strcat(apebuf,"\""); 2837. add_autopickup_exception(apebuf); 2838. goto ape_again; 2839. } else if (opt_idx == 3) { 2840. retval = TRUE; 2841. } else { /* remove */ 2842. tmpwin = create_nhwindow(NHW_MENU); 2843. start_menu(tmpwin); 2844. for (pass = AP_LEAVE; pass <= AP_GRAB; ++pass) { 2845. if (numapes[pass] == 0) continue; 2846. ape = iflags.autopickup_exceptions[pass]; 2847. any.a_void = 0; 2848. add_menu(tmpwin, NO_GLYPH, &any, 0, 0, iflags.menu_headings, 2849. (pass == 0) ? "Never pickup" : "Always pickup", 2850. MENU_UNSELECTED); 2851. for (i = 0; i < numapes[pass] && ape; i++) { 2852. any.a_void = (opt_idx == 1) ? 0 : ape; 2853. Sprintf(apebuf, "\"%s\"", ape->pattern); 2854. add_menu(tmpwin, NO_GLYPH, &any, 2855. 0, 0, ATR_NONE, apebuf, MENU_UNSELECTED); 2856. ape = ape->next; 2857. } 2858. } 2859. Sprintf(apebuf, "%s autopickup exceptions", 2860. (opt_idx == 1) ? "List of" : "Remove which"); 2861. end_menu(tmpwin, apebuf); 2862. pick_cnt = select_menu(tmpwin, 2863. (opt_idx == 1) ? PICK_NONE : PICK_ANY, 2864. &pick_list); 2865. if (pick_cnt > 0) { 2866. for (pick_idx = 0; pick_idx < pick_cnt; ++pick_idx) 2867. remove_autopickup_exception( 2868. (struct autopickup_exception *)pick_list[pick_idx].item.a_void); 2869. } 2870. free((genericptr_t)pick_list); 2871. pick_list = (menu_item *)0; 2872. destroy_nhwindow(tmpwin); 2873. goto ape_again; 2874. } 2875. retval = TRUE; 2876. #endif /* AUTOPICKUP_EXCEPTIONS */ 2877. } 2878. return retval; 2879. } 2880.
get_compopbt_value
2881. #define rolestring(val,array,field) ((val >= 0) ? array[val].field : \ 2882. (val == ROLE_RANDOM) ? randomrole : none) 2883. 2884. /* This is ugly. We have all the option names in the compopt[] array, 2885. but we need to look at each option individually to get the value. */ 2886. STATIC_OVL const char * 2887. get_compopt_value(optname, buf) 2888. const char *optname; 2889. char *buf; 2890. { 2891. char ocl[MAXOCLASSES+1]; 2892. static const char none[] = "(none)", randomrole[] = "random", 2893. to_be_done[] = "(to be done)", 2894. defopt[] = "default", 2895. defbrief[] = "def"; 2896. int i; 2897. 2898. buf[0] = '\0'; 2899. if (!strcmp(optname,"align_message")) 2900. Sprintf(buf, "%s", iflags.wc_align_message == ALIGN_TOP ? "top" : 2901. iflags.wc_align_message == ALIGN_LEFT ? "left" : 2902. iflags.wc_align_message == ALIGN_BOTTOM ? "bottom" : 2903. iflags.wc_align_message == ALIGN_RIGHT ? "right" : 2904. defopt); 2905. else if (!strcmp(optname,"align_status")) 2906. Sprintf(buf, "%s", iflags.wc_align_status == ALIGN_TOP ? "top" : 2907. iflags.wc_align_status == ALIGN_LEFT ? "left" : 2908. iflags.wc_align_status == ALIGN_BOTTOM ? "bottom" : 2909. iflags.wc_align_status == ALIGN_RIGHT ? "right" : 2910. defopt); 2911. else if (!strcmp(optname,"align")) 2912. Sprintf(buf, "%s", rolestring(flags.initalign, aligns, adj)); 2913. #ifdef WIN32CON 2914. else if (!strcmp(optname,"altkeyhandler")) 2915. Sprintf(buf, "%s", iflags.altkeyhandler[0] ? 2916. iflags.altkeyhandler : "default"); 2917. #endif 2918. else if (!strcmp(optname, "boulder")) 2919. Sprintf(buf, "%c", iflags.bouldersym ? 2920. iflags.bouldersym : oc_syms[(int)objects[BOULDER].oc_class]); 2921. else if (!strcmp(optname, "catname")) 2922. Sprintf(buf, "%s", catname[0] ? catname : none ); 2923. else if (!strcmp(optname, "disclose")) { 2924. for (i = 0; i < NUM_DISCLOSURE_OPTIONS; i++) { 2925. char topt[2]; 2926. if (i) Strcat(buf," "); 2927. topt[1] = '\0'; 2928. topt[0] = flags.end_disclose[i]; 2929. Strcat(buf, topt); 2930. topt[0] = disclosure_options[i]; 2931. Strcat(buf, topt); 2932. } 2933. } 2934. else if (!strcmp(optname, "dogname")) 2935. Sprintf(buf, "%s", dogname[0] ? dogname : none ); 2936. else if (!strcmp(optname, "dungeon")) 2937. Sprintf(buf, "%s", to_be_done); 2938. else if (!strcmp(optname, "effects")) 2939. Sprintf(buf, "%s", to_be_done); 2940. else if (!strcmp(optname, "font_map")) 2941. Sprintf(buf, "%s", iflags.wc_font_map ? iflags.wc_font_map : defopt); 2942. else if (!strcmp(optname, "font_message")) 2943. Sprintf(buf, "%s", iflags.wc_font_message ? iflags.wc_font_message : defopt); 2944. else if (!strcmp(optname, "font_status")) 2945. Sprintf(buf, "%s", iflags.wc_font_status ? iflags.wc_font_status : defopt); 2946. else if (!strcmp(optname, "font_menu")) 2947. Sprintf(buf, "%s", iflags.wc_font_menu ? iflags.wc_font_menu : defopt); 2948. else if (!strcmp(optname, "font_text")) 2949. Sprintf(buf, "%s", iflags.wc_font_text ? iflags.wc_font_text : defopt); 2950. else if (!strcmp(optname, "font_size_map")) { 2951. if (iflags.wc_fontsiz_map) Sprintf(buf, "%d", iflags.wc_fontsiz_map); 2952. else Strcpy(buf, defopt); 2953. } 2954. else if (!strcmp(optname, "font_size_message")) { 2955. if (iflags.wc_fontsiz_message) Sprintf(buf, "%d", 2956. iflags.wc_fontsiz_message); 2957. else Strcpy(buf, defopt); 2958. } 2959. else if (!strcmp(optname, "font_size_status")) { 2960. if (iflags.wc_fontsiz_status) Sprintf(buf, "%d", iflags.wc_fontsiz_status); 2961. else Strcpy(buf, defopt); 2962. } 2963. else if (!strcmp(optname, "font_size_menu")) { 2964. if (iflags.wc_fontsiz_menu) Sprintf(buf, "%d", iflags.wc_fontsiz_menu); 2965. else Strcpy(buf, defopt); 2966. } 2967. else if (!strcmp(optname, "font_size_text")) { 2968. if (iflags.wc_fontsiz_text) Sprintf(buf, "%d",iflags.wc_fontsiz_text); 2969. else Strcpy(buf, defopt); 2970. } 2971. else if (!strcmp(optname, "fruit")) 2972. Sprintf(buf, "%s", pl_fruit); 2973. else if (!strcmp(optname, "gender")) 2974. Sprintf(buf, "%s", rolestring(flags.initgend, genders, adj)); 2975. else if (!strcmp(optname, "horsename")) 2976. Sprintf(buf, "%s", horsename[0] ? horsename : none); 2977. else if (!strcmp(optname, "map_mode")) 2978. Sprintf(buf, "%s", 2979. iflags.wc_map_mode == MAP_MODE_TILES ? "tiles" : 2980. iflags.wc_map_mode == MAP_MODE_ASCII4x6 ? "ascii4x6" : 2981. iflags.wc_map_mode == MAP_MODE_ASCII6x8 ? "ascii6x8" : 2982. iflags.wc_map_mode == MAP_MODE_ASCII8x8 ? "ascii8x8" : 2983. iflags.wc_map_mode == MAP_MODE_ASCII16x8 ? "ascii16x8" : 2984. iflags.wc_map_mode == MAP_MODE_ASCII7x12 ? "ascii7x12" : 2985. iflags.wc_map_mode == MAP_MODE_ASCII8x12 ? "ascii8x12" : 2986. iflags.wc_map_mode == MAP_MODE_ASCII16x12 ? "ascii16x12" : 2987. iflags.wc_map_mode == MAP_MODE_ASCII12x16 ? "ascii12x16" : 2988. iflags.wc_map_mode == MAP_MODE_ASCII10x18 ? "ascii10x18" : 2989. iflags.wc_map_mode == MAP_MODE_ASCII_FIT_TO_SCREEN ? 2990. "fit_to_screen" : defopt); 2991. else if (!strcmp(optname, "menustyle")) 2992. Sprintf(buf, "%s", menutype[(int)flags.menu_style] ); 2993. else if (!strcmp(optname, "menu_deselect_all")) 2994. Sprintf(buf, "%s", to_be_done); 2995. else if (!strcmp(optname, "menu_deselect_page")) 2996. Sprintf(buf, "%s", to_be_done); 2997. else if (!strcmp(optname, "menu_first_page")) 2998. Sprintf(buf, "%s", to_be_done); 2999. else if (!strcmp(optname, "menu_invert_all")) 3000. Sprintf(buf, "%s", to_be_done); 3001. else if (!strcmp(optname, "menu_headings")) { 3002. Sprintf(buf, "%s", (iflags.menu_headings == ATR_BOLD) ? 3003. "bold" : (iflags.menu_headings == ATR_INVERSE) ? 3004. "inverse" : (iflags.menu_headings == ATR_ULINE) ? 3005. "underline" : "unknown"); 3006. } 3007. else if (!strcmp(optname, "menu_invert_page")) 3008. Sprintf(buf, "%s", to_be_done); 3009. else if (!strcmp(optname, "menu_last_page")) 3010. Sprintf(buf, "%s", to_be_done); 3011. else if (!strcmp(optname, "menu_next_page")) 3012. Sprintf(buf, "%s", to_be_done); 3013. else if (!strcmp(optname, "menu_previous_page")) 3014. Sprintf(buf, "%s", to_be_done); 3015. else if (!strcmp(optname, "menu_search")) 3016. Sprintf(buf, "%s", to_be_done); 3017. else if (!strcmp(optname, "menu_select_all")) 3018. Sprintf(buf, "%s", to_be_done); 3019. else if (!strcmp(optname, "menu_select_page")) 3020. Sprintf(buf, "%s", to_be_done); 3021. else if (!strcmp(optname, "monsters")) 3022. Sprintf(buf, "%s", to_be_done); 3023. else if (!strcmp(optname, "msghistory")) 3024. Sprintf(buf, "%u", iflags.msg_history); 3025. #ifdef TTY_GRAPHICS 3026. else if (!strcmp(optname, "msg_window")) 3027. Sprintf(buf, "%s", (iflags.prevmsg_window=='s') ? "single" : 3028. (iflags.prevmsg_window=='c') ? "combination" : 3029. (iflags.prevmsg_window=='f') ? "full" : "reversed"); 3030. #endif 3031. else if (!strcmp(optname, "name")) 3032. Sprintf(buf, "%s", plname); 3033. else if (!strcmp(optname, "number_pad")) 3034. Sprintf(buf, "%s", 3035. (!iflags.num_pad) ? "0=off" : 3036. (iflags.num_pad_mode) ? "2=on, DOS compatible" : "1=on"); 3037. else if (!strcmp(optname, "objects")) 3038. Sprintf(buf, "%s", to_be_done); 3039. else if (!strcmp(optname, "packorder")) { 3040. oc_to_str(flags.inv_order, ocl); 3041. Sprintf(buf, "%s", ocl); 3042. } 3043. #ifdef CHANGE_COLOR 3044. else if (!strcmp(optname, "palette")) 3045. Sprintf(buf, "%s", get_color_string()); 3046. #endif 3047. else if (!strcmp(optname, "pettype")) 3048. Sprintf(buf, "%s", (preferred_pet == 'c') ? "cat" : 3049. (preferred_pet == 'd') ? "dog" : 3050. (preferred_pet == 'n') ? "none" : "random"); 3051. else if (!strcmp(optname, "pickup_burden")) 3052. Sprintf(buf, "%s", burdentype[flags.pickup_burden] ); 3053. else if (!strcmp(optname, "pickup_types")) { 3054. oc_to_str(flags.pickup_types, ocl); 3055. Sprintf(buf, "%s", ocl[0] ? ocl : "all" ); 3056. } 3057. else if (!strcmp(optname, "race")) 3058. Sprintf(buf, "%s", rolestring(flags.initrace, races, noun)); 3059. else if (!strcmp(optname, "role")) 3060. Sprintf(buf, "%s", rolestring(flags.initrole, roles, name.m)); 3061. else if (!strcmp(optname, "runmode")) 3062. Sprintf(buf, "%s", runmodes[iflags.runmode]); 3063. else if (!strcmp(optname, "scores")) { 3064. Sprintf(buf, "%d top/%d around%s", flags.end_top, 3065. flags.end_around, flags.end_own ? "/own" : ""); 3066. } 3067. else if (!strcmp(optname, "scroll_amount")) { 3068. if (iflags.wc_scroll_amount) Sprintf(buf, "%d",iflags.wc_scroll_amount); 3069. else Strcpy(buf, defopt); 3070. } 3071. else if (!strcmp(optname, "scroll_margin")) { 3072. if (iflags.wc_scroll_margin) Sprintf(buf, "%d",iflags.wc_scroll_margin); 3073. else Strcpy(buf, defopt); 3074. } 3075. else if (!strcmp(optname, "player_selection")) 3076. Sprintf(buf, "%s", iflags.wc_player_selection ? "prompts" : "dialog"); 3077. #ifdef MSDOS 3078. else if (!strcmp(optname, "soundcard")) 3079. Sprintf(buf, "%s", to_be_done); 3080. #endif 3081. else if (!strcmp(optname, "suppress_alert")) { 3082. if (flags.suppress_alert == 0L) 3083. Strcpy(buf, none); 3084. else 3085. Sprintf(buf, "%lu.%lu.%lu", 3086. FEATURE_NOTICE_VER_MAJ, 3087. FEATURE_NOTICE_VER_MIN, 3088. FEATURE_NOTICE_VER_PATCH); 3089. } 3090. else if (!strcmp(optname, "tile_file")) 3091. Sprintf(buf, "%s", iflags.wc_tile_file ? iflags.wc_tile_file : defopt); 3092. else if (!strcmp(optname, "tile_height")) { 3093. if (iflags.wc_tile_height) Sprintf(buf, "%d",iflags.wc_tile_height); 3094. else Strcpy(buf, defopt); 3095. } 3096. else if (!strcmp(optname, "tile_width")) { 3097. if (iflags.wc_tile_width) Sprintf(buf, "%d",iflags.wc_tile_width); 3098. else Strcpy(buf, defopt); 3099. } 3100. else if (!strcmp(optname, "traps")) 3101. Sprintf(buf, "%s", to_be_done); 3102. else if (!strcmp(optname, "vary_msgcount")) { 3103. if (iflags.wc_vary_msgcount) Sprintf(buf, "%d",iflags.wc_vary_msgcount); 3104. else Strcpy(buf, defopt); 3105. } 3106. #ifdef MSDOS 3107. else if (!strcmp(optname, "video")) 3108. Sprintf(buf, "%s", to_be_done); 3109. #endif 3110. #ifdef VIDEOSHADES 3111. else if (!strcmp(optname, "videoshades")) 3112. Sprintf(buf, "%s-%s-%s", shade[0],shade[1],shade[2]); 3113. else if (!strcmp(optname, "videocolors")) 3114. Sprintf(buf, "%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d", 3115. ttycolors[CLR_RED], ttycolors[CLR_GREEN], 3116. ttycolors[CLR_BROWN], ttycolors[CLR_BLUE], 3117. ttycolors[CLR_MAGENTA], ttycolors[CLR_CYAN], 3118. ttycolors[CLR_ORANGE], ttycolors[CLR_BRIGHT_GREEN], 3119. ttycolors[CLR_YELLOW], ttycolors[CLR_BRIGHT_BLUE], 3120. ttycolors[CLR_BRIGHT_MAGENTA], 3121. ttycolors[CLR_BRIGHT_CYAN]); 3122. #endif /* VIDEOSHADES */ 3123. else if (!strcmp(optname, "windowtype")) 3124. Sprintf(buf, "%s", windowprocs.name); 3125. else if (!strcmp(optname, "windowcolors")) 3126. Sprintf(buf, "%s/%s %s/%s %s/%s %s/%s", 3127. iflags.wc_foregrnd_menu ? iflags.wc_foregrnd_menu : defbrief, 3128. iflags.wc_backgrnd_menu ? iflags.wc_backgrnd_menu : defbrief, 3129. iflags.wc_foregrnd_message ? iflags.wc_foregrnd_message : defbrief, 3130. iflags.wc_backgrnd_message ? iflags.wc_backgrnd_message : defbrief, 3131. iflags.wc_foregrnd_status ? iflags.wc_foregrnd_status : defbrief, 3132. iflags.wc_backgrnd_status ? iflags.wc_backgrnd_status : defbrief, 3133. iflags.wc_foregrnd_text ? iflags.wc_foregrnd_text : defbrief, 3134. iflags.wc_backgrnd_text ? iflags.wc_backgrnd_text : defbrief); 3135. #ifdef PREFIXES_IN_USE 3136. else { 3137. for (i = 0; i < PREFIX_COUNT; ++i) 3138. if (!strcmp(optname, fqn_prefix_names[i]) && fqn_prefix[i]) 3139. Sprintf(buf, "%s", fqn_prefix[i]); 3140. } 3141. #endif 3142. 3143. if (buf[0]) return buf; 3144. else return "unknown"; 3145. } 3146.
dotogglepickup
3147. int 3148. dotogglepickup() 3149. { 3150. char buf[BUFSZ], ocl[MAXOCLASSES+1]; 3151. 3152. flags.pickup = !flags.pickup; 3153. if (flags.pickup) { 3154. oc_to_str(flags.pickup_types, ocl); 3155. Sprintf(buf, "ON, for %s objects%s", ocl[0] ? ocl : "all", 3156. #ifdef AUTOPICKUP_EXCEPTIONS 3157. (iflags.autopickup_exceptions[AP_LEAVE] || 3158. iflags.autopickup_exceptions[AP_GRAB]) ? 3159. ((count_ape_maps((int *)0, (int *)0) == 1) ? 3160. ", with one exception" : ", with some exceptions") : 3161. #endif 3162. ""); 3163. } else { 3164. Strcpy(buf, "OFF"); 3165. } 3166. pline("Autopickup: %s.", buf); 3167. return 0; 3168. } 3169.
add_autopickup_exception
3170. #ifdef AUTOPICKUP_EXCEPTIONS 3171. int 3172. add_autopickup_exception(mapping) 3173. const char *mapping; 3174. { 3175. struct autopickup_exception *ape, **apehead; 3176. char text[256], *text2; 3177. int textsize = 0; 3178. boolean grab = FALSE; 3179. 3180. if (sscanf(mapping, "\"%255[^\"]\"", text) == 1) { 3181. text2 = &text[0]; 3182. if (*text2 == '<') { /* force autopickup */ 3183. grab = TRUE; 3184. ++text2; 3185. } else if (*text2 == '>') { /* default - Do not pickup */ 3186. grab = FALSE; 3187. ++text2; 3188. } 3189. textsize = strlen(text2); 3190. apehead = (grab) ? &iflags.autopickup_exceptions[AP_GRAB] : 3191. &iflags.autopickup_exceptions[AP_LEAVE]; 3192. ape = (struct autopickup_exception *) 3193. alloc(sizeof(struct autopickup_exception)); 3194. ape->pattern = (char *) alloc(textsize+1); 3195. Strcpy(ape->pattern, text2); 3196. ape->grab = grab; 3197. if (!*apehead) ape->next = (struct autopickup_exception *)0; 3198. else ape->next = *apehead; 3199. *apehead = ape; 3200. } else { 3201. raw_print("syntax error in AUTOPICKUP_EXCEPTION"); 3202. return 0; 3203. } 3204. return 1; 3205. } 3206.
remove_autopickuo_exception
3207. STATIC_OVL void 3208. remove_autopickup_exception(whichape) 3209. struct autopickup_exception *whichape; 3210. { 3211. struct autopickup_exception *ape, *prev = 0; 3212. int chain = whichape->grab ? AP_GRAB : AP_LEAVE; 3213. 3214. for (ape = iflags.autopickup_exceptions[chain]; ape;) { 3215. if (ape == whichape) { 3216. struct autopickup_exception *freeape = ape; 3217. ape = ape->next; 3218. if (prev) prev->next = ape; 3219. else iflags.autopickup_exceptions[chain] = ape; 3220. free(freeape->pattern); 3221. free(freeape); 3222. } else { 3223. prev = ape; 3224. ape = ape->next; 3225. } 3226. } 3227. } 3228.
count_ape_maps
3229. STATIC_OVL int 3230. count_ape_maps(leave, grab) 3231. int *leave, *grab; 3232. { 3233. struct autopickup_exception *ape; 3234. int pass, totalapes, numapes[2] = {0,0}; 3235. 3236. for (pass = AP_LEAVE; pass <= AP_GRAB; ++pass) { 3237. ape = iflags.autopickup_exceptions[pass]; 3238. while(ape) { 3239. ape = ape->next; 3240. numapes[pass]++; 3241. } 3242. } 3243. totalapes = numapes[AP_LEAVE] + numapes[AP_GRAB]; 3244. if (leave) *leave = numapes[AP_LEAVE]; 3245. if (grab) *grab = numapes[AP_GRAB]; 3246. return totalapes; 3247. } 3248.
free_autopickup_exceptions
3249. void 3250. free_autopickup_exceptions() 3251. { 3252. struct autopickup_exception *ape; 3253. int pass; 3254. 3255. for (pass = AP_LEAVE; pass <= AP_GRAB; ++pass) { 3256. while((ape = iflags.autopickup_exceptions[pass]) != 0) { 3257. free(ape->pattern); 3258. iflags.autopickup_exceptions[pass] = ape->next; 3259. free(ape); 3260. } 3261. } 3262. } 3263. #endif /* AUTOPICKUP_EXCEPTIONS */ 3264.
option_help
3265. /* data for option_help() */ 3266. static const char *opt_intro[] = { 3267. "", 3268. " NetHack Options Help:", 3269. "", 3270. #define CONFIG_SLOT 3 /* fill in next value at run-time */ 3271. (char *)0, 3272. #if !defined(MICRO) && !defined(MAC) 3273. "or use `NETHACKOPTIONS=\"<options>\"' in your environment", 3274. #endif 3275. "(<options> is a list of options separated by commas)", 3276. #ifdef VMS 3277. "-- for example, $ DEFINE NETHACKOPTIONS \"noautopickup,fruit:kumquat\"", 3278. #endif 3279. "or press \"O\" while playing and use the menu.", 3280. "", 3281. "Boolean options (which can be negated by prefixing them with '!' or \"no\"):", 3282. (char *)0 3283. }; 3284. 3285. static const char *opt_epilog[] = { 3286. "", 3287. "Some of the options can be set only before the game is started; those", 3288. "items will not be selectable in the 'O' command's menu.", 3289. (char *)0 3290. }; 3291. 3292. void 3293. option_help() 3294. { 3295. char buf[BUFSZ], buf2[BUFSZ]; 3296. register int i; 3297. winid datawin; 3298. 3299. datawin = create_nhwindow(NHW_TEXT); 3300. Sprintf(buf, "Set options as OPTIONS=<options> in %s", configfile); 3301. opt_intro[CONFIG_SLOT] = (const char *) buf; 3302. for (i = 0; opt_intro[i]; i++) 3303. putstr(datawin, 0, opt_intro[i]); 3304. 3305. /* Boolean options */ 3306. for (i = 0; boolopt[i].name; i++) { 3307. if (boolopt[i].addr) { 3308. #ifdef WIZARD 3309. if (boolopt[i].addr == &iflags.sanity_check && !wizard) continue; 3310. if (boolopt[i].addr == &iflags.menu_tab_sep && !wizard) continue; 3311. #endif 3312. next_opt(datawin, boolopt[i].name); 3313. } 3314. } 3315. next_opt(datawin, ""); 3316. 3317. /* Compound options */ 3318. putstr(datawin, 0, "Compound options:"); 3319. for (i = 0; compopt[i].name; i++) { 3320. Sprintf(buf2, "`%s'", compopt[i].name); 3321. Sprintf(buf, "%-20s - %s%c", buf2, compopt[i].descr, 3322. compopt[i+1].name ? ',' : '.'); 3323. putstr(datawin, 0, buf); 3324. } 3325. 3326. for (i = 0; opt_epilog[i]; i++) 3327. putstr(datawin, 0, opt_epilog[i]); 3328. 3329. display_nhwindow(datawin, FALSE); 3330. destroy_nhwindow(datawin); 3331. return; 3332. } 3333.
next_opt
3334. /* 3335. * prints the next boolean option, on the same line if possible, on a new 3336. * line if not. End with next_opt(""). 3337. */ 3338. void 3339. next_opt(datawin, str) 3340. winid datawin; 3341. const char *str; 3342. { 3343. static char *buf = 0; 3344. int i; 3345. char *s; 3346. 3347. if (!buf) *(buf = (char *)alloc(BUFSZ)) = '\0'; 3348. 3349. if (!*str) { 3350. s = eos(buf); 3351. if (s > &buf[1] && s[-2] == ',') 3352. Strcpy(s - 2, "."); /* replace last ", " */ 3353. i = COLNO; /* (greater than COLNO - 2) */ 3354. } else { 3355. i = strlen(buf) + strlen(str) + 2; 3356. } 3357. 3358. if (i > COLNO - 2) { /* rule of thumb */ 3359. putstr(datawin, 0, buf); 3360. buf[0] = 0; 3361. } 3362. if (*str) { 3363. Strcat(buf, str); 3364. Strcat(buf, ", "); 3365. } else { 3366. putstr(datawin, 0, str); 3367. free(buf), buf = 0; 3368. } 3369. return; 3370. } 3371.
fruitadd
3372. /* Returns the fid of the fruit type; if that type already exists, it 3373. * returns the fid of that one; if it does not exist, it adds a new fruit 3374. * type to the chain and returns the new one. 3375. */ 3376. int 3377. fruitadd(str) 3378. char *str; 3379. { 3380. register int i; 3381. register struct fruit *f; 3382. struct fruit *lastf = 0; 3383. int highest_fruit_id = 0; 3384. char buf[PL_FSIZ]; 3385. boolean user_specified = (str == pl_fruit); 3386. /* if not user-specified, then it's a fruit name for a fruit on 3387. * a bones level... 3388. */ 3389. 3390. /* Note: every fruit has an id (spe for fruit objects) of at least 3391. * 1; 0 is an error. 3392. */ 3393. if (user_specified) { 3394. /* disallow naming after other foods (since it'd be impossible 3395. * to tell the difference) 3396. */ 3397. 3398. boolean found = FALSE, numeric = FALSE; 3399. 3400. for (i = bases[FOOD_CLASS]; objects[i].oc_class == FOOD_CLASS; 3401. i++) { 3402. if (!strcmp(OBJ_NAME(objects[i]), pl_fruit)) { 3403. found = TRUE; 3404. break; 3405. } 3406. } 3407. { 3408. char *c; 3409. 3410. c = pl_fruit; 3411. 3412. for(c = pl_fruit; *c >= '0' && *c <= '9'; c++) 3413. ; 3414. if (isspace(*c) || *c == 0) numeric = TRUE; 3415. } 3416. if (found || numeric || 3417. !strncmp(str, "cursed ", 7) || 3418. !strncmp(str, "uncursed ", 9) || 3419. !strncmp(str, "blessed ", 8) || 3420. !strncmp(str, "partly eaten ", 13) || 3421. (!strncmp(str, "tin of ", 7) && 3422. (!strcmp(str+7, "spinach") || 3423. name_to_mon(str+7) >= LOW_PM)) || 3424. !strcmp(str, "empty tin") || 3425. ((!strncmp(eos(str)-7," corpse",7) || 3426. !strncmp(eos(str)-4, " egg",4)) && 3427. name_to_mon(str) >= LOW_PM)) 3428. { 3429. Strcpy(buf, pl_fruit); 3430. Strcpy(pl_fruit, "candied "); 3431. nmcpy(pl_fruit+8, buf, PL_FSIZ-8); 3432. } 3433. } 3434. for(f=ffruit; f; f = f->nextf) { 3435. lastf = f; 3436. if(f->fid > highest_fruit_id) highest_fruit_id = f->fid; 3437. if(!strncmp(str, f->fname, PL_FSIZ)) 3438. goto nonew; 3439. } 3440. /* if adding another fruit would overflow spe, use a random 3441. fruit instead... we've got a lot to choose from. */ 3442. if (highest_fruit_id >= 127) return rnd(127); 3443. highest_fruit_id++; 3444. f = newfruit(); 3445. if (ffruit) lastf->nextf = f; 3446. else ffruit = f; 3447. Strcpy(f->fname, str); 3448. f->fid = highest_fruit_id; 3449. f->nextf = 0; 3450. nonew: 3451. if (user_specified) current_fruit = highest_fruit_id; 3452. return f->fid; 3453. } 3454.
3455. /* 3456. * This is a somewhat generic menu for taking a list of NetHack style 3457. * class choices and presenting them via a description 3458. * rather than the traditional NetHack characters. 3459. * (Benefits users whose first exposure to NetHack is via tiles). 3460. * 3461. * prompt 3462. * The title at the top of the menu. 3463. * 3464. * category: 0 = monster class 3465. * 1 = object class 3466. * 3467. * way 3468. * FALSE = PICK_ONE, TRUE = PICK_ANY 3469. * 3470. * class_list 3471. * a null terminated string containing the list of choices. 3472. * 3473. * class_selection 3474. * a null terminated string containing the selected characters. 3475. * 3476. * Returns number selected. 3477. */ 3478. int 3479. choose_classes_menu(prompt, category, way, class_list, class_select) 3480. const char *prompt; 3481. int category; 3482. boolean way; 3483. char *class_list; 3484. char *class_select; 3485. { 3486. menu_item *pick_list = (menu_item *)0; 3487. winid win; 3488. anything any; 3489. char buf[BUFSZ]; 3490. int i, n; 3491. int ret; 3492. int next_accelerator, accelerator; 3493. 3494. if (class_list == (char *)0 || class_select == (char *)0) return 0; 3495. accelerator = 0; 3496. next_accelerator = 'a'; 3497. any.a_void = 0; 3498. win = create_nhwindow(NHW_MENU); 3499. start_menu(win); 3500. while (*class_list) { 3501. const char *text; 3502. boolean selected; 3503. 3504. text = (char *)0; 3505. selected = FALSE; 3506. switch (category) { 3507. case 0: 3508. text = monexplain[def_char_to_monclass(*class_list)]; 3509. accelerator = *class_list; 3510. Sprintf(buf, "%s", text); 3511. break; 3512. case 1: 3513. text = objexplain[def_char_to_objclass(*class_list)]; 3514. accelerator = next_accelerator; 3515. Sprintf(buf, "%c %s", *class_list, text); 3516. break; 3517. default: 3518. impossible("choose_classes_menu: invalid category %d", 3519. category); 3520. } 3521. if (way && *class_select) { /* Selections there already */ 3522. if (index(class_select, *class_list)) { 3523. selected = TRUE; 3524. } 3525. } 3526. any.a_int = *class_list; 3527. add_menu(win, NO_GLYPH, &any, accelerator, 3528. category ? *class_list : 0, 3529. ATR_NONE, buf, selected); 3530. ++class_list; 3531. if (category > 0) { 3532. ++next_accelerator; 3533. if (next_accelerator == ('z' + 1)) next_accelerator = 'A'; 3534. if (next_accelerator == ('Z' + 1)) break; 3535. } 3536. } 3537. end_menu(win, prompt); 3538. n = select_menu(win, way ? PICK_ANY : PICK_ONE, &pick_list); 3539. destroy_nhwindow(win); 3540. if (n > 0) { 3541. for (i = 0; i < n; ++i) 3542. *class_select++ = (char)pick_list[i].item.a_int; 3543. free((genericptr_t)pick_list); 3544. ret = n; 3545. } else if (n == -1) { 3546. class_select = eos(class_select); 3547. ret = -1; 3548. } else 3549. ret = 0; 3550. *class_select = '\0'; 3551. return ret; 3552. } 3553.
3554. struct wc_Opt wc_options[] = { 3555. {"ascii_map", WC_ASCII_MAP}, 3556. {"color", WC_COLOR}, 3557. {"eight_bit_tty", WC_EIGHT_BIT_IN}, 3558. {"hilite_pet", WC_HILITE_PET}, 3559. {"popup_dialog", WC_POPUP_DIALOG}, 3560. {"player_selection", WC_PLAYER_SELECTION}, 3561. {"preload_tiles", WC_PRELOAD_TILES}, 3562. {"tiled_map", WC_TILED_MAP}, 3563. {"tile_file", WC_TILE_FILE}, 3564. {"tile_width", WC_TILE_WIDTH}, 3565. {"tile_height", WC_TILE_HEIGHT}, 3566. {"use_inverse", WC_INVERSE}, 3567. {"align_message", WC_ALIGN_MESSAGE}, 3568. {"align_status", WC_ALIGN_STATUS}, 3569. {"font_map", WC_FONT_MAP}, 3570. {"font_menu", WC_FONT_MENU}, 3571. {"font_message",WC_FONT_MESSAGE}, 3572. #if 0 3573. {"perm_invent",WC_PERM_INVENT}, 3574. #endif 3575. {"font_size_map", WC_FONTSIZ_MAP}, 3576. {"font_size_menu", WC_FONTSIZ_MENU}, 3577. {"font_size_message", WC_FONTSIZ_MESSAGE}, 3578. {"font_size_status", WC_FONTSIZ_STATUS}, 3579. {"font_size_text", WC_FONTSIZ_TEXT}, 3580. {"font_status", WC_FONT_STATUS}, 3581. {"font_text", WC_FONT_TEXT}, 3582. {"map_mode", WC_MAP_MODE}, 3583. {"scroll_amount", WC_SCROLL_AMOUNT}, 3584. {"scroll_margin", WC_SCROLL_MARGIN}, 3585. {"splash_screen", WC_SPLASH_SCREEN}, 3586. {"vary_msgcount",WC_VARY_MSGCOUNT}, 3587. {"windowcolors", WC_WINDOWCOLORS}, 3588. {"mouse_support", WC_MOUSE_SUPPORT}, 3589. {(char *)0, 0L} 3590. }; 3591. 3592. struct wc_Opt wc2_options[] = { 3593. {"fullscreen", WC2_FULLSCREEN}, 3594. {"softkeyboard", WC2_SOFTKEYBOARD}, 3595. {"wraptext", WC2_WRAPTEXT}, 3596. {(char *)0, 0L} 3597. }; 3598. 3599.
set_option_mod_status
3600. /* 3601. * If a port wants to change or ensure that the 3602. * SET_IN_FILE, DISP_IN_GAME, or SET_IN_GAME status of an option is 3603. * correct (for controlling its display in the option menu) call 3604. * set_option_mod_status() 3605. * with the second argument of 0,2, or 3 respectively. 3606. */ 3607. void 3608. set_option_mod_status(optnam, status) 3609. const char *optnam; 3610. int status; 3611. { 3612. int k; 3613. if (status < SET_IN_FILE || status > SET_IN_GAME) { 3614. impossible("set_option_mod_status: status out of range %d.", 3615. status); 3616. return; 3617. } 3618. for (k = 0; boolopt[k].name; k++) { 3619. if (!strncmpi(boolopt[k].name, optnam, strlen(optnam))) { 3620. boolopt[k].optflags = status; 3621. return; 3622. } 3623. } 3624. for (k = 0; compopt[k].name; k++) { 3625. if (!strncmpi(compopt[k].name, optnam, strlen(optnam))) { 3626. compopt[k].optflags = status; 3627. return; 3628. } 3629. } 3630. } 3631.
set_wc_option_mod_status
3632. /* 3633. * You can set several wc_options in one call to 3634. * set_wc_option_mod_status() by setting 3635. * the appropriate bits for each option that you 3636. * are setting in the optmask argument 3637. * prior to calling. 3638. * example: set_wc_option_mod_status(WC_COLOR|WC_SCROLL_MARGIN, SET_IN_GAME); 3639. */ 3640. void 3641. set_wc_option_mod_status(optmask, status) 3642. unsigned long optmask; 3643. int status; 3644. { 3645. int k = 0; 3646. if (status < SET_IN_FILE || status > SET_IN_GAME) { 3647. impossible("set_wc_option_mod_status: status out of range %d.", 3648. status); 3649. return; 3650. } 3651. while (wc_options[k].wc_name) { 3652. if (optmask & wc_options[k].wc_bit) { 3653. set_option_mod_status(wc_options[k].wc_name, status); 3654. } 3655. k++; 3656. } 3657. } 3658.
is_wc_option
3659. STATIC_OVL boolean 3660. is_wc_option(optnam) 3661. const char *optnam; 3662. { 3663. int k = 0; 3664. while (wc_options[k].wc_name) { 3665. if (strcmp(wc_options[k].wc_name, optnam) == 0) 3666. return TRUE; 3667. k++; 3668. } 3669. return FALSE; 3670. } 3671.
wc_supported
3672. STATIC_OVL boolean 3673. wc_supported(optnam) 3674. const char *optnam; 3675. { 3676. int k = 0; 3677. while (wc_options[k].wc_name) { 3678. if (!strcmp(wc_options[k].wc_name, optnam) && 3679. (windowprocs.wincap & wc_options[k].wc_bit)) 3680. return TRUE; 3681. k++; 3682. } 3683. return FALSE; 3684. } 3685. 3686.
set_wc2_option_mod_status
3687. /* 3688. * You can set several wc2_options in one call to 3689. * set_wc2_option_mod_status() by setting 3690. * the appropriate bits for each option that you 3691. * are setting in the optmask argument 3692. * prior to calling. 3693. * example: set_wc2_option_mod_status(WC2_FULLSCREEN|WC2_SOFTKEYBOARD|WC2_WRAPTEXT, SET_IN_FILE); 3694. */ 3695. 3696. void 3697. set_wc2_option_mod_status(optmask, status) 3698. unsigned long optmask; 3699. int status; 3700. { 3701. int k = 0; 3702. if (status < SET_IN_FILE || status > SET_IN_GAME) { 3703. impossible("set_wc2_option_mod_status: status out of range %d.", 3704. status); 3705. return; 3706. } 3707. while (wc2_options[k].wc_name) { 3708. if (optmask & wc2_options[k].wc_bit) { 3709. set_option_mod_status(wc2_options[k].wc_name, status); 3710. } 3711. k++; 3712. } 3713. } 3714.
is_wc2_option
3715. STATIC_OVL boolean 3716. is_wc2_option(optnam) 3717. const char *optnam; 3718. { 3719. int k = 0; 3720. while (wc2_options[k].wc_name) { 3721. if (strcmp(wc2_options[k].wc_name, optnam) == 0) 3722. return TRUE; 3723. k++; 3724. } 3725. return FALSE; 3726. } 3727.
wc2_supported
3728. STATIC_OVL boolean 3729. wc2_supported(optnam) 3730. const char *optnam; 3731. { 3732. int k = 0; 3733. while (wc2_options[k].wc_name) { 3734. if (!strcmp(wc2_options[k].wc_name, optnam) && 3735. (windowprocs.wincap2 & wc2_options[k].wc_bit)) 3736. return TRUE; 3737. k++; 3738. } 3739. return FALSE; 3740. } 3741. 3742.
wc_set_font_name
3743. STATIC_OVL void 3744. wc_set_font_name(wtype, fontname) 3745. int wtype; 3746. char *fontname; 3747. { 3748. char **fn = (char **)0; 3749. if (!fontname) return; 3750. switch(wtype) { 3751. case NHW_MAP: 3752. fn = &iflags.wc_font_map; 3753. break; 3754. case NHW_MESSAGE: 3755. fn = &iflags.wc_font_message; 3756. break; 3757. case NHW_TEXT: 3758. fn = &iflags.wc_font_text; 3759. break; 3760. case NHW_MENU: 3761. fn = &iflags.wc_font_menu; 3762. break; 3763. case NHW_STATUS: 3764. fn = &iflags.wc_font_status; 3765. break; 3766. default: 3767. return; 3768. } 3769. if (fn) { 3770. if (*fn) free(*fn); 3771. *fn = (char *)alloc(strlen(fontname) + 1); 3772. Strcpy(*fn, fontname); 3773. } 3774. return; 3775. } 3776.
wc_set_window_colors
3777. STATIC_OVL int 3778. wc_set_window_colors(op) 3779. char *op; 3780. { 3781. /* syntax: 3782. * menu white/black message green/yellow status white/blue text white/black 3783. */ 3784. 3785. int j; 3786. char buf[BUFSZ]; 3787. char *wn, *tfg, *tbg, *newop; 3788. static const char *wnames[] = { "menu", "message", "status", "text" }; 3789. static const char *shortnames[] = { "mnu", "msg", "sts", "txt" }; 3790. static char **fgp[] = { 3791. &iflags.wc_foregrnd_menu, 3792. &iflags.wc_foregrnd_message, 3793. &iflags.wc_foregrnd_status, 3794. &iflags.wc_foregrnd_text 3795. }; 3796. static char **bgp[] = { 3797. &iflags.wc_backgrnd_menu, 3798. &iflags.wc_backgrnd_message, 3799. &iflags.wc_backgrnd_status, 3800. &iflags.wc_backgrnd_text 3801. }; 3802. 3803. Strcpy(buf, op); 3804. newop = mungspaces(buf); 3805. while (newop && *newop) { 3806. 3807. wn = tfg = tbg = (char *)0; 3808. 3809. /* until first non-space in case there's leading spaces - before colorname*/ 3810. while(*newop && isspace(*newop)) newop++; 3811. if (*newop) wn = newop; 3812. else return 0; 3813. 3814. /* until first space - colorname*/ 3815. while(*newop && !isspace(*newop)) newop++; 3816. if (*newop) *newop = '\0'; 3817. else return 0; 3818. newop++; 3819. 3820. /* until first non-space - before foreground*/ 3821. while(*newop && isspace(*newop)) newop++; 3822. if (*newop) tfg = newop; 3823. else return 0; 3824. 3825. /* until slash - foreground */ 3826. while(*newop && *newop != '/') newop++; 3827. if (*newop) *newop = '\0'; 3828. else return 0; 3829. newop++; 3830. 3831. /* until first non-space (in case there's leading space after slash) - before background */ 3832. while(*newop && isspace(*newop)) newop++; 3833. if (*newop) tbg = newop; 3834. else return 0; 3835. 3836. /* until first space - background */ 3837. while(*newop && !isspace(*newop)) newop++; 3838. if (*newop) *newop++ = '\0'; 3839. 3840. for (j = 0; j < 4; ++j) { 3841. if (!strcmpi(wn, wnames[j]) || 3842. !strcmpi(wn, shortnames[j])) { 3843. if (tfg && !strstri(tfg, " ")) { 3844. if (*fgp[j]) free(*fgp[j]); 3845. *fgp[j] = (char *)alloc(strlen(tfg) + 1); 3846. Strcpy(*fgp[j], tfg); 3847. } 3848. if (tbg && !strstri(tbg, " ")) { 3849. if (*bgp[j]) free(*bgp[j]); 3850. *bgp[j] = (char *)alloc(strlen(tbg) + 1); 3851. Strcpy(*bgp[j], tbg); 3852. } 3853. break; 3854. } 3855. } 3856. } 3857. return 1; 3858. } 3859. 3860. #endif /* OPTION_LISTS_ONLY */ 3861. 3862. /*options.c*/