![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to options.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / xrogue|
Return to options.c CVS log | Up to [contributed] / early-roguelike / xrogue |
1.1 ! rubenllo 1: /*
! 2: options.c - This file has all the code for the option command
! 3:
! 4: XRogue: Expeditions into the Dungeons of Doom
! 5: Copyright (C) 1991 Robert Pietkivitch
! 6: All rights reserved.
! 7:
! 8: Based on "Advanced Rogue"
! 9: Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka and AT&T
! 10: All rights reserved.
! 11:
! 12: Based on "Rogue: Exploring the Dungeons of Doom"
! 13: Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
! 14: All rights reserved.
! 15:
! 16: See the file LICENSE.TXT for full copyright and licensing information.
! 17: */
! 18:
! 19: /*
! 20: * I would rather this command were not necessary, but
! 21: * it is the only way to keep the wolves off of my back.
! 22: */
! 23:
! 24: #include <curses.h>
! 25: #include <ctype.h>
! 26: #include <string.h>
! 27: #include "rogue.h"
! 28:
! 29: #define NUM_OPTS (sizeof optlist / sizeof (OPTION))
! 30:
! 31: /*
! 32: * description of an option and what to do with it
! 33: */
! 34: struct optstruct {
! 35: char *o_name; /* option name */
! 36: char *o_prompt; /* prompt for interactive entry */
! 37: void *o_opt; /* pointer to thing to set */
! 38: void (*o_putfunc)(); /* function to print value */
! 39: int (*o_getfunc)(); /* function to get value interactively */
! 40: };
! 41:
! 42: typedef struct optstruct OPTION;
! 43:
! 44: int get_ro(WINDOW *win, int oy, int ox);
! 45: void put_bool(bool *b, WINDOW *win);
! 46: int get_bool(bool *bp, WINDOW *win);
! 47: void put_str(char *str, WINDOW *win);
! 48: int get_str(char *opt, WINDOW *win);
! 49: void put_abil(int *ability, WINDOW *win);
! 50: int get_abil(int *abil, WINDOW *win);
! 51: void put_quest(int *quest, WINDOW *win);
! 52: int get_quest(int *quest, WINDOW *win);
! 53: int get_default(bool *bp, WINDOW *win);
! 54: int get_str_prot(char *opt, WINDOW *win);
! 55: int get_score(char *opt, WINDOW *win);
! 56: bool allowchange(OPTION *op);
! 57:
! 58: OPTION optlist[] = {
! 59: {"terse", "Terse output: ",
! 60: (void *) &terse, put_bool, get_bool },
! 61: {"flush", "Flush typeahead during battle: ",
! 62: (void *) &fight_flush, put_bool, get_bool },
! 63: {"jump", "Show position only at end of run: ",
! 64: (void *) &jump, put_bool, get_bool },
! 65: {"step", "Do inventories one line at a time: ",
! 66: (void *) &slow_invent, put_bool, get_bool },
! 67: {"askme", "Ask me about unidentified things: ",
! 68: (void *) &askme, put_bool, get_bool },
! 69: {"pickup", "Pick things up automatically: ",
! 70: (void *) &auto_pickup, put_bool, get_bool },
! 71: {"overlay", "Overlay menu: ",
! 72: (void *) &menu_overlay, put_bool, get_bool },
! 73: {"name", "Name: ",
! 74: (void *) whoami, put_str, get_str_prot },
! 75: {"file", "Save file: ",
! 76: (void *) file_name, put_str, get_str_prot },
! 77: {"score", "Score file: ",
! 78: (void *) score_file, put_str, get_score },
! 79: {"class", "Character type: ",
! 80: (void *) &char_type, put_abil, get_abil },
! 81: {"quest", "Quest item: ",
! 82: (void *) &quest_item, put_quest, get_quest },
! 83: {"default", "Default Attributes: ",
! 84: (void *) &def_attr, put_bool, get_default }
! 85: };
! 86:
! 87: /*
! 88: * The default attribute field is read-only
! 89: */
! 90:
! 91: int
! 92: get_default(bool *bp, WINDOW *win)
! 93: {
! 94: register int oy, ox;
! 95:
! 96: getyx(win, oy, ox);
! 97: put_bool(bp, win);
! 98: return get_ro(win, oy, ox);
! 99: }
! 100:
! 101: /*
! 102: * The ability (class) field is read-only
! 103: */
! 104:
! 105: int
! 106: get_abil(int *abil, WINDOW *win)
! 107: {
! 108: register int oy, ox;
! 109:
! 110: getyx(win, oy, ox);
! 111: put_abil(abil, win);
! 112: return get_ro(win, oy, ox);
! 113: }
! 114:
! 115: /*
! 116: * The quest field is read-only
! 117: */
! 118:
! 119: int
! 120: get_quest(int *quest, WINDOW *win)
! 121: {
! 122: register int oy, ox;
! 123:
! 124: getyx(win, oy, ox);
! 125: waddstr(win, rel_magic[*quest].mi_name);
! 126: return get_ro(win, oy, ox);
! 127: }
! 128:
! 129: /*
! 130: * get_ro:
! 131: * "Get" a read-only value.
! 132: */
! 133:
! 134: int
! 135: get_ro(WINDOW *win, int oy, int ox)
! 136: {
! 137: register int ny, nx;
! 138: register bool op_bad;
! 139:
! 140: op_bad = TRUE;
! 141: getyx(win, ny, nx);
! 142: while(op_bad)
! 143: {
! 144: wmove(win, oy, ox);
! 145: draw(win);
! 146: switch (wgetch(win))
! 147: {
! 148: case '\n':
! 149: case '\r':
! 150: op_bad = FALSE;
! 151: break;
! 152: case '\033':
! 153: case '\007':
! 154: return QUIT;
! 155: case '-':
! 156: return MINUS;
! 157: default:
! 158: mvwaddstr(win, ny, nx + 5, "(no change allowed)");
! 159: }
! 160: }
! 161: wmove(win, ny, nx + 5);
! 162: wclrtoeol(win);
! 163: wmove(win, ny, nx);
! 164: waddch(win, '\n');
! 165: return NORM;
! 166: }
! 167:
! 168: /*
! 169: * allow changing a boolean option and print it out
! 170: */
! 171:
! 172: int
! 173: get_bool(bool *bp, WINDOW *win)
! 174: {
! 175: register int oy, ox;
! 176: register bool op_bad;
! 177:
! 178: op_bad = TRUE;
! 179: getyx(win, oy, ox);
! 180: waddstr(win, *bp ? "True" : "False");
! 181: while(op_bad)
! 182: {
! 183: wmove(win, oy, ox);
! 184: draw(win);
! 185: switch (wgetch(win))
! 186: {
! 187: case 't':
! 188: case 'T':
! 189: *bp = TRUE;
! 190: op_bad = FALSE;
! 191: break;
! 192: case 'f':
! 193: case 'F':
! 194: *bp = FALSE;
! 195: op_bad = FALSE;
! 196: break;
! 197: case '\n':
! 198: case '\r':
! 199: op_bad = FALSE;
! 200: break;
! 201: case '\033':
! 202: case '\007':
! 203: return QUIT;
! 204: case '-':
! 205: return MINUS;
! 206: default:
! 207: mvwaddstr(win, oy, ox + 10, "(T or F)");
! 208: }
! 209: }
! 210: wmove(win, oy, ox);
! 211: wclrtoeol(win);
! 212: waddstr(win, *bp ? "True" : "False");
! 213: waddch(win, '\n');
! 214: return NORM;
! 215: }
! 216:
! 217: /*
! 218: * set a string option
! 219: */
! 220:
! 221: int
! 222: get_str(char *opt, WINDOW *win)
! 223: {
! 224: register char *sp;
! 225: register int c, oy, ox;
! 226: char buf[LINELEN];
! 227:
! 228: draw(win);
! 229: getyx(win, oy, ox);
! 230: /*
! 231: * loop reading in the string, and put it in a temporary buffer
! 232: */
! 233: for (sp = buf;
! 234: (c = wgetch(win)) != '\n' &&
! 235: c != '\r' &&
! 236: c != '\033' &&
! 237: c != '\007' &&
! 238: sp < &buf[LINELEN-1];
! 239: wclrtoeol(win), draw(win))
! 240: {
! 241: if (c == -1)
! 242: continue;
! 243: else if (c == erasechar()) /* process erase character */
! 244: {
! 245: if (sp > buf)
! 246: {
! 247: register int i;
! 248:
! 249: sp--;
! 250: for (i = strlen(unctrl(*sp)); i; i--)
! 251: waddch(win, '\b');
! 252: }
! 253: continue;
! 254: }
! 255: else if (c == killchar()) /* process kill character */
! 256: {
! 257: sp = buf;
! 258: wmove(win, oy, ox);
! 259: continue;
! 260: }
! 261: else if (sp == buf)
! 262: if (c == '-' && win == hw) /* To move back a line in hw */
! 263: break;
! 264: else if (c == '~')
! 265: {
! 266: strcpy(buf, home);
! 267: waddstr(win, home);
! 268: sp += strlen(home);
! 269: continue;
! 270: }
! 271: *sp++ = c;
! 272: waddstr(win, unctrl(c));
! 273: }
! 274: *sp = '\0';
! 275: if (sp > buf) /* only change option if something has been typed */
! 276: strucpy(opt, buf, strlen(buf));
! 277: wmove(win, oy, ox);
! 278: waddstr(win, opt);
! 279: waddch(win, '\n');
! 280: draw(win);
! 281: if (win == msgw)
! 282: mpos += sp - buf;
! 283: if (c == '-')
! 284: return MINUS;
! 285: else if (c == '\033' || c == '\007')
! 286: return QUIT;
! 287: else
! 288: return NORM;
! 289: }
! 290:
! 291: /*
! 292: * print and then set options from the terminal
! 293: */
! 294:
! 295: void
! 296: option(void)
! 297: {
! 298: register OPTION *op;
! 299: register int retval;
! 300:
! 301: wclear(hw);
! 302: touchwin(hw);
! 303: /*
! 304: * Display current values of options
! 305: */
! 306: for (op = optlist; op < &optlist[NUM_OPTS]; op++)
! 307: {
! 308: waddstr(hw, op->o_prompt);
! 309: (*op->o_putfunc)(op->o_opt, hw);
! 310: waddch(hw, '\n');
! 311: }
! 312: /*
! 313: * Set values
! 314: */
! 315: wmove(hw, 0, 0);
! 316: for (op = optlist; op < &optlist[NUM_OPTS]; op++)
! 317: {
! 318: waddstr(hw, op->o_prompt);
! 319:
! 320: retval = (*op->o_getfunc)(op->o_opt, hw);
! 321:
! 322: if (retval)
! 323: if (retval == QUIT)
! 324: break;
! 325: else if (op > optlist) { /* MINUS */
! 326: wmove(hw, (op - optlist) - 1, 0);
! 327: op -= 2;
! 328: }
! 329: else /* trying to back up beyond the top */
! 330: {
! 331: putchar('\007');
! 332: wmove(hw, 0, 0);
! 333: op--;
! 334: }
! 335: }
! 336: /*
! 337: * Switch back to original screen
! 338: */
! 339: mvwaddstr(hw, lines-1, 0, spacemsg);
! 340: draw(hw);
! 341: wait_for(' ');
! 342: restscr(cw);
! 343: after = FALSE;
! 344: }
! 345:
! 346: /*
! 347: * parse options from string, usually taken from the environment.
! 348: * the string is a series of comma seperated values, with booleans
! 349: * being stated as "name" (true) or "noname" (false), and strings
! 350: * being "name=....", with the string being defined up to a comma
! 351: * or the end of the entire option string.
! 352: */
! 353:
! 354: void
! 355: parse_opts(char *str)
! 356: {
! 357: register char *sp;
! 358: register OPTION *op;
! 359: register int len;
! 360:
! 361: if (*str == '\"')
! 362: str++;
! 363:
! 364: while (*str)
! 365: {
! 366: /*
! 367: * Get option name
! 368: */
! 369:
! 370: for (sp = str; isalpha(*sp); sp++)
! 371: continue;
! 372: len = (char *)sp - str;
! 373: /*
! 374: * Look it up and deal with it
! 375: */
! 376: for (op = optlist; op < &optlist[NUM_OPTS]; op++)
! 377: {
! 378: if (EQSTR(str, op->o_name, len))
! 379: {
! 380: if (op->o_putfunc == put_bool) /* if option is a boolean */
! 381: *(bool *)op->o_opt = TRUE;
! 382: else /* string option */
! 383: {
! 384: register char *start;
! 385: char value[LINELEN];
! 386:
! 387: /*
! 388: * Skip to start of string value
! 389: */
! 390: for (str = sp + 1; *str == '=' || *str == ':'; str++)
! 391: continue;
! 392:
! 393: if (*str == '~')
! 394: {
! 395: strcpy((char *) value, home);
! 396: start = (char *) value + strlen(home);
! 397: while (*++str == '/')
! 398: continue;
! 399: }
! 400: else
! 401: start = (char *) value;
! 402: /*
! 403: * Skip to end of string value
! 404: */
! 405: for (sp = str + 1; *sp && *sp != ',' && *sp != '\"'; sp++)
! 406: continue;
! 407: strucpy(start, str, (char *) sp - str);
! 408:
! 409: /* Put the value into the option field */
! 410: if (op->o_putfunc != put_abil) {
! 411: if (allowchange(op))
! 412: strcpy((char *)op->o_opt, value);
! 413: }
! 414:
! 415: else if (*(int *)op->o_opt == -1) {
! 416: /* Only init ability once */
! 417: register int len = strlen(value);
! 418: register int i;
! 419:
! 420: for (i=0; i<NUM_CHARTYPES-1; i++) {
! 421: if (EQSTR(value, char_class[i].name, len)) {
! 422: *(int *)op->o_opt = i;
! 423: break;
! 424: }
! 425: }
! 426: }
! 427: }
! 428: break;
! 429: }
! 430: /*
! 431: * check for "noname" for booleans
! 432: */
! 433: else if (op->o_putfunc == put_bool
! 434: && EQSTR(str, "no", 2) && EQSTR(str + 2, op->o_name, len - 2))
! 435: {
! 436: *(bool *)op->o_opt = FALSE;
! 437: break;
! 438: }
! 439: }
! 440:
! 441: /*
! 442: * skip to start of next option name
! 443: */
! 444: while (*sp && !isalpha(*sp))
! 445: sp++;
! 446: str = sp;
! 447: }
! 448: }
! 449:
! 450:
! 451: /*
! 452: * print the default attributes
! 453: */
! 454:
! 455: /* put_default(b, win)
! 456: * bool *b;
! 457: * WINDOW *win;
! 458: * {
! 459: * waddstr(win, *b ? "True" : "False");
! 460: * }
! 461: */
! 462:
! 463: /*
! 464: * print the character type
! 465: */
! 466:
! 467: void
! 468: put_abil(int *ability, WINDOW *win)
! 469: {
! 470: waddstr(win, char_class[*ability].name);
! 471: }
! 472:
! 473: /*
! 474: * print out the quest
! 475: */
! 476:
! 477: void
! 478: put_quest(int *quest, WINDOW *win)
! 479: {
! 480: waddstr(win, rel_magic[*quest].mi_name);
! 481: }
! 482:
! 483: /*
! 484: * put out a boolean
! 485: */
! 486:
! 487: void
! 488: put_bool(bool *b, WINDOW *win)
! 489: {
! 490: waddstr(win, *b ? "True" : "False");
! 491: }
! 492:
! 493: /*
! 494: * put out a string
! 495: */
! 496:
! 497: void
! 498: put_str(char *str, WINDOW *win)
! 499: {
! 500: waddstr(win, str);
! 501: }
! 502:
! 503: /* Like get_str, but disallows changes when use_savedir is set. */
! 504: int
! 505: get_str_prot(char *opt, WINDOW *win)
! 506: {
! 507: int oy, ox;
! 508:
! 509: if (use_savedir) {
! 510: getyx(win, oy, ox);
! 511: waddstr(win, opt);
! 512: return get_ro(win, oy, ox);
! 513: }
! 514: else {
! 515: return get_str(opt, win);
! 516: }
! 517: }
! 518:
! 519: /* When getting the scorefile, the new file must be opened. */
! 520: int
! 521: get_score(char *optstr, WINDOW *win)
! 522: {
! 523: char old_score_file[LINELEN];
! 524: int status;
! 525:
! 526: if (use_savedir)
! 527: return get_str_prot(optstr, win);
! 528:
! 529: strcpy(old_score_file, optstr);
! 530: status = get_str(optstr, win);
! 531: if (status == NORM && strcmp(old_score_file, optstr))
! 532: {
! 533: if (scorefi != NULL)
! 534: fclose(scorefi);
! 535: scorefi = fopen(score_file, "rb+");
! 536: if (scorefi == NULL)
! 537: scorefi = fopen(score_file, "wb+");
! 538: }
! 539: return status;
! 540: }
! 541:
! 542: bool
! 543: allowchange(OPTION *op)
! 544: {
! 545: if (!use_savedir)
! 546: return TRUE;
! 547: if (!strcmp(op->o_name, "name"))
! 548: return FALSE;
! 549: if (!strcmp(op->o_name, "file"))
! 550: return FALSE;
! 551: if (!strcmp(op->o_name, "score"))
! 552: return FALSE;
! 553: return TRUE;
! 554: }