![[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 / rogue5|
Return to options.c CVS log | Up to [contributed] / early-roguelike / rogue5 |
1.1 ! rubenllo 1: /*
! 2: * This file has all the code for the option command. I would rather
! 3: * this command were not necessary, but it is the only way to keep the
! 4: * wolves off of my back.
! 5: *
! 6: * @(#)options.c 4.24 (Berkeley) 05/10/83
! 7: *
! 8: * Rogue: Exploring the Dungeons of Doom
! 9: * Copyright (C) 1980-1983, 1985, 1999 Michael Toy, Ken Arnold and Glenn Wichman
! 10: * All rights reserved.
! 11: *
! 12: * See the file LICENSE.TXT for full copyright and licensing information.
! 13: */
! 14:
! 15: #include <stdlib.h>
! 16: #include <curses.h>
! 17: #include <ctype.h>
! 18: #include <string.h>
! 19: #include "rogue.h"
! 20:
! 21: #define EQSTR(a, b, c) (strncmp(a, b, c) == 0)
! 22:
! 23: #define NUM_OPTS (sizeof optlist / sizeof (OPTION))
! 24:
! 25: /*
! 26: * description of an option and what to do with it
! 27: */
! 28: struct optstruct {
! 29: char *o_name; /* option name */
! 30: char *o_prompt; /* prompt for interactive entry */
! 31: void *o_opt; /* pointer to thing to set */
! 32: /* function to print value */
! 33: void (*o_putfunc)(void *opt);
! 34: /* function to get value interactively */
! 35: int (*o_getfunc)(void *opt, WINDOW *win);
! 36: };
! 37:
! 38: typedef struct optstruct OPTION;
! 39:
! 40: void pr_optname(const OPTION *op);
! 41: int allowchange(const OPTION *op);
! 42:
! 43: static const OPTION optlist[] = {
! 44: {"terse", "Terse output",
! 45: &terse, put_bool, get_bool },
! 46: {"flush", "Flush typeahead during battle",
! 47: &fight_flush, put_bool, get_bool },
! 48: {"jump", "Show position only at end of run",
! 49: &jump, put_bool, get_bool },
! 50: {"seefloor", "Show the lamp-illuminated floor",
! 51: &see_floor, put_bool, get_sf },
! 52: {"passgo", "Follow turnings in passageways",
! 53: &passgo, put_bool, get_bool },
! 54: {"tombstone", "Print out tombstone when killed",
! 55: &tombstone, put_bool, get_bool },
! 56: {"inven", "Inventory style",
! 57: &inv_type, put_inv_t, get_inv_t },
! 58: {"name", "Name",
! 59: whoami, put_str, get_str },
! 60: {"fruit", "Fruit",
! 61: fruit, put_str, get_str },
! 62: {"file", "Save file",
! 63: file_name, put_str, get_str }
! 64: };
! 65:
! 66: /*
! 67: * option:
! 68: * Print and then set options from the terminal
! 69: */
! 70:
! 71: void
! 72: option(void)
! 73: {
! 74: const OPTION *op;
! 75: int retval;
! 76:
! 77: wclear(hw);
! 78: /*
! 79: * Display current values of options
! 80: */
! 81: for (op = optlist; op <= &optlist[NUM_OPTS-1]; op++)
! 82: {
! 83: if (allowchange(op))
! 84: {
! 85: pr_optname(op);
! 86: (*op->o_putfunc)(op->o_opt);
! 87: waddch(hw, '\n');
! 88: }
! 89: }
! 90: /*
! 91: * Set values
! 92: */
! 93: wmove(hw, 0, 0);
! 94: for (op = optlist; op <= &optlist[NUM_OPTS-1]; op++)
! 95: {
! 96: if (!allowchange(op))
! 97: continue;
! 98: pr_optname(op);
! 99: retval = (*op->o_getfunc)(op->o_opt, hw);
! 100: if (retval)
! 101: {
! 102: if (retval == QUIT)
! 103: break;
! 104: #if 0
! 105: /* Support for MINUS removed until this section is rewritten. */
! 106: else if (op > optlist) { /* MINUS */
! 107: wmove(hw, (int)(op - optlist) - 1, 0);
! 108: op -= 2;
! 109: }
! 110: else /* trying to back up beyond the top */
! 111: {
! 112: putchar('\007');
! 113: wmove(hw, 0, 0);
! 114: op--;
! 115: }
! 116: #else
! 117: break;
! 118: #endif
! 119: }
! 120: }
! 121: /*
! 122: * Switch back to original screen
! 123: */
! 124: wmove(hw, LINES - 1, 0);
! 125: waddstr(hw, "--Press space to continue--");
! 126: wrefresh(hw);
! 127: wait_for(hw, ' ');
! 128: clearok(curscr, TRUE);
! 129: touchwin(stdscr);
! 130: after = FALSE;
! 131: }
! 132:
! 133: /*
! 134: * pr_optname:
! 135: * Print out the option name prompt
! 136: */
! 137:
! 138: void
! 139: pr_optname(const OPTION *op)
! 140: {
! 141: wprintw(hw, "%s (\"%s\"): ", op->o_prompt, op->o_name);
! 142: }
! 143:
! 144: /*
! 145: * put_bool
! 146: * Put out a boolean
! 147: */
! 148:
! 149: void
! 150: put_bool(void *b)
! 151: {
! 152: waddstr(hw, *(int *) b ? "True" : "False");
! 153: }
! 154:
! 155: /*
! 156: * put_str:
! 157: * Put out a string
! 158: */
! 159:
! 160: void
! 161: put_str(void *str)
! 162: {
! 163: waddstr(hw, (char *) str);
! 164: }
! 165:
! 166: /*
! 167: * put_inv_t:
! 168: * Put out an inventory type
! 169: */
! 170:
! 171: void
! 172: put_inv_t(void *ip)
! 173: {
! 174: waddstr(hw, inv_t_name[*(int *) ip]);
! 175: }
! 176:
! 177: /*
! 178: * get_bool:
! 179: * Allow changing a boolean option and print it out
! 180: */
! 181: int
! 182: get_bool(void *vp, WINDOW *win)
! 183: {
! 184: int *bp = (int *) vp;
! 185: int oy, ox;
! 186: int op_bad;
! 187:
! 188: op_bad = TRUE;
! 189: getyx(win, oy, ox);
! 190: waddstr(win, *bp ? "True" : "False");
! 191: while (op_bad)
! 192: {
! 193: wmove(win, oy, ox);
! 194: wrefresh(win);
! 195: switch (wreadchar(win))
! 196: {
! 197: case 't':
! 198: case 'T':
! 199: *bp = TRUE;
! 200: op_bad = FALSE;
! 201: break;
! 202: case 'f':
! 203: case 'F':
! 204: *bp = FALSE;
! 205: op_bad = FALSE;
! 206: break;
! 207: case '\n':
! 208: case '\r':
! 209: op_bad = FALSE;
! 210: break;
! 211: case ESCAPE:
! 212: return QUIT;
! 213: case '-':
! 214: return MINUS;
! 215: default:
! 216: wmove(win, oy, ox + 10);
! 217: waddstr(win, "(T or F)");
! 218: }
! 219: }
! 220: wmove(win, oy, ox);
! 221: waddstr(win, *bp ? "True" : "False");
! 222: waddch(win, '\n');
! 223: return NORM;
! 224: }
! 225:
! 226: /*
! 227: * get_sf:
! 228: * Change value and handle transition problems from see_floor to
! 229: * !see_floor.
! 230: */
! 231: int
! 232: get_sf(void *vp, WINDOW *win)
! 233: {
! 234: int *bp = (int *) vp;
! 235: int was_sf;
! 236: int retval;
! 237:
! 238: was_sf = see_floor;
! 239: retval = get_bool(bp, win);
! 240: if (retval == QUIT) return(QUIT);
! 241: if (was_sf != see_floor)
! 242: {
! 243: if (!see_floor) {
! 244: see_floor = TRUE;
! 245: erase_lamp(&hero, proom);
! 246: see_floor = FALSE;
! 247: }
! 248: else
! 249: look(FALSE);
! 250: }
! 251: return(NORM);
! 252: }
! 253:
! 254: /*
! 255: * get_str:
! 256: * Set a string option
! 257: */
! 258: #define MAXINP 50 /* max string to read from terminal or environment */
! 259:
! 260: int
! 261: get_str(void *vopt, WINDOW *win)
! 262: {
! 263: char *opt = (char *) vopt;
! 264: char *sp;
! 265: int oy, ox;
! 266: size_t i;
! 267: int c;
! 268: static char buf[MAXSTR];
! 269:
! 270: getyx(win, oy, ox);
! 271: wrefresh(win);
! 272: /*
! 273: * loop reading in the string, and put it in a temporary buffer
! 274: */
! 275: for (sp = buf; (c = wreadchar(win)) != '\n' && c != '\r' && c != ESCAPE;
! 276: wclrtoeol(win), wrefresh(win))
! 277: {
! 278: if (c == -1)
! 279: continue;
! 280: else if (c == erasechar()) /* process erase character */
! 281: {
! 282: if (sp > buf)
! 283: {
! 284: sp--;
! 285: for (i = strlen(unctrl(*sp)); i; i--)
! 286: waddch(win, '\b');
! 287: }
! 288: continue;
! 289: }
! 290: else if (c == killchar()) /* process kill character */
! 291: {
! 292: sp = buf;
! 293: wmove(win, oy, ox);
! 294: continue;
! 295: }
! 296: else if (sp == buf)
! 297: {
! 298: if (c == '-' && win != stdscr)
! 299: break;
! 300: else if (c == '~')
! 301: {
! 302: strcpy(buf, home);
! 303: waddstr(win, home);
! 304: sp += strlen(home);
! 305: continue;
! 306: }
! 307: }
! 308: if (sp >= &buf[MAXINP] || !(isprint(c) || c == ' '))
! 309: putchar(CTRL('G'));
! 310: else
! 311: {
! 312: *sp++ = (char) c;
! 313: waddstr(win, unctrl(c));
! 314: }
! 315: }
! 316: *sp = '\0';
! 317: if (sp > buf) /* only change option if something has been typed */
! 318: strucpy(opt, buf, strlen(buf));
! 319: mvwprintw(win, oy, ox, "%s\n", opt);
! 320: wrefresh(win);
! 321: if (win == stdscr)
! 322: mpos += (int)(sp - buf);
! 323: if (c == '-')
! 324: return MINUS;
! 325: else if (c == ESCAPE)
! 326: return QUIT;
! 327: else
! 328: return NORM;
! 329: }
! 330:
! 331: /*
! 332: * get_inv_t
! 333: * Get an inventory type name
! 334: */
! 335: int
! 336: get_inv_t(void *vp, WINDOW *win)
! 337: {
! 338: int *ip = (int *) vp;
! 339: int oy, ox;
! 340: int op_bad;
! 341:
! 342: op_bad = TRUE;
! 343: getyx(win, oy, ox);
! 344: waddstr(win, inv_t_name[*ip]);
! 345: while (op_bad)
! 346: {
! 347: wmove(win, oy, ox);
! 348: wrefresh(win);
! 349: switch (wreadchar(win))
! 350: {
! 351: case 'o':
! 352: case 'O':
! 353: *ip = INV_OVER;
! 354: op_bad = FALSE;
! 355: break;
! 356: case 's':
! 357: case 'S':
! 358: *ip = INV_SLOW;
! 359: op_bad = FALSE;
! 360: break;
! 361: case 'c':
! 362: case 'C':
! 363: *ip = INV_CLEAR;
! 364: op_bad = FALSE;
! 365: break;
! 366: case '\n':
! 367: case '\r':
! 368: op_bad = FALSE;
! 369: break;
! 370: case ESCAPE:
! 371: return QUIT;
! 372: case '-':
! 373: return MINUS;
! 374: default:
! 375: wmove(win, oy, ox + 15);
! 376: waddstr(win, "(O, S, or C)");
! 377: }
! 378: }
! 379: mvwprintw(win, oy, ox, "%s\n", inv_t_name[*ip]);
! 380: return NORM;
! 381: }
! 382:
! 383:
! 384: #ifdef MASTER
! 385: /*
! 386: * get_num:
! 387: * Get a numeric option
! 388: */
! 389: int
! 390: get_num(void *vp, WINDOW *win)
! 391: {
! 392: int *opt = (int *) vp;
! 393: int i;
! 394: static char buf[MAXSTR];
! 395:
! 396: if ((i = get_str(buf, win)) == NORM)
! 397: *opt = atoi(buf);
! 398: return i;
! 399: }
! 400: #endif
! 401:
! 402: /*
! 403: * parse_opts:
! 404: * Parse options from string, usually taken from the environment.
! 405: * The string is a series of comma seperated values, with booleans
! 406: * being stated as "name" (true) or "noname" (false), and strings
! 407: * being "name=....", with the string being defined up to a comma
! 408: * or the end of the entire option string.
! 409: */
! 410:
! 411: void
! 412: parse_opts(char *str)
! 413: {
! 414: char *sp;
! 415: const OPTION *op;
! 416: int len;
! 417: const char **i;
! 418: char *start;
! 419:
! 420: while (*str)
! 421: {
! 422: /*
! 423: * Get option name
! 424: */
! 425: for (sp = str; isalpha((int)*sp); sp++)
! 426: continue;
! 427: len = (int)(sp - str);
! 428: /*
! 429: * Look it up and deal with it
! 430: */
! 431: for (op = optlist; op <= &optlist[NUM_OPTS-1]; op++)
! 432: {
! 433: if (!allowchange(op))
! 434: continue;
! 435: if (EQSTR(str, op->o_name, len))
! 436: {
! 437: if (op->o_putfunc == put_bool) /* if option is a boolean */
! 438: *(int *)op->o_opt = TRUE; /* NOSTRICT */
! 439: else /* string option */
! 440: {
! 441: /*
! 442: * Skip to start of string value
! 443: */
! 444: for (str = sp + 1; *str == '='; str++)
! 445: continue;
! 446: if (*str == '~')
! 447: {
! 448: strcpy((char *) op->o_opt, home); /* NOSTRICT */
! 449: start = (char *) op->o_opt + strlen(home);/* NOSTRICT */
! 450: while (*++str == '/')
! 451: continue;
! 452: }
! 453: else
! 454: start = (char *) op->o_opt; /* NOSTRICT */
! 455: /*
! 456: * Skip to end of string value
! 457: */
! 458: for (sp = str + 1; *sp && *sp != ','; sp++)
! 459: continue;
! 460: /*
! 461: * check for type of inventory
! 462: */
! 463: if (op->o_putfunc == put_inv_t)
! 464: {
! 465: if (islower((int)*str))
! 466: *str = (char) toupper(*str);
! 467: for (i = inv_t_name; i <= &inv_t_name[INV_CLEAR]; i++)
! 468: if (strncmp(str, *i, sp - str) == 0)
! 469: {
! 470: inv_type = (int)(i - inv_t_name);
! 471: break;
! 472: }
! 473: }
! 474: else
! 475: strucpy(start, str, (size_t)(sp - str));
! 476: }
! 477: break;
! 478: }
! 479: /*
! 480: * check for "noname" for booleans
! 481: */
! 482: else if (op->o_putfunc == put_bool
! 483: && EQSTR(str, "no", 2) && EQSTR(str + 2, op->o_name, len - 2))
! 484: {
! 485: *(int *)op->o_opt = FALSE; /* NOSTRICT */
! 486: break;
! 487: }
! 488: }
! 489:
! 490: /*
! 491: * skip to start of next option name
! 492: */
! 493: while (*sp && !isalpha((int)*sp))
! 494: sp++;
! 495: str = sp;
! 496: }
! 497: }
! 498:
! 499: /*
! 500: * strucpy:
! 501: * Copy string using unctrl for things
! 502: */
! 503:
! 504: void
! 505: strucpy(char *s1, const char *s2, size_t len)
! 506: {
! 507: if (len > MAXINP)
! 508: len = MAXINP;
! 509: while (len--)
! 510: {
! 511: if (isprint((int)*s2) || *s2 == ' ')
! 512: *s1++ = *s2;
! 513: s2++;
! 514: }
! 515: *s1 = '\0';
! 516: }
! 517:
! 518: /* Tells whether the user is allowed to change the option. */
! 519: int
! 520: allowchange(const OPTION *opt)
! 521: {
! 522: if (!use_savedir)
! 523: return TRUE;
! 524: if (!strcmp(opt->o_name, "name"))
! 525: return FALSE;
! 526: if (!strcmp(opt->o_name, "file"))
! 527: return FALSE;
! 528: return TRUE;
! 529: }