![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wump.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / games / wump|
Return to wump.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / wump |
1.1 ! root 1: /* ! 2: * Copyright (c) 1989 The Regents of the University of California. ! 3: * Copyright (c) 1989 Dave Taylor, Intuitive Systems. ! 4: * All rights reserved. ! 5: * ! 6: * This code is derived from software contributed to Berkeley by ! 7: * Dave Taylor, of Intuitive Systems. ! 8: * ! 9: * Redistribution and use in source and binary forms are permitted provided ! 10: * that: (1) source distributions retain this entire copyright notice and ! 11: * comment, and (2) distributions including binaries display the following ! 12: * acknowledgement: ``This product includes software developed by the ! 13: * University of California, Berkeley and its contributors'' in the ! 14: * documentation or other materials provided with the distribution and in ! 15: * all advertising materials mentioning features or use of this software. ! 16: * Neither the name of the University nor the names of its contributors may ! 17: * be used to endorse or promote products derived from this software without ! 18: * specific prior written permission. ! 19: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 20: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 21: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 22: LAR PURPOSE. ! 23: */ ! 24: ! 25: #ifndef lint ! 26: char copyright[] = ! 27: "@(#) Copyright (c) 1989 The Regents of the University of California.\n\ ! 28: All rights reserved.\n"; ! 29: #endif /* not lint */ ! 30: ! 31: #ifndef lint ! 32: static char sccsid[] = "@(#)wump.c 4.3 (Berkeley) 6/1/90"; ! 33: #endif /* not lint */ ! 34: ! 35: /* ! 36: * A very new version of the age old favorite Hunt-The-Wumpus game that has ! 37: * been a part of the BSD distribution of Unix for longer than us old folk ! 38: * would care to remember. ! 39: */ ! 40: ! 41: #include <sys/types.h> ! 42: #include <sys/file.h> ! 43: #include <stdio.h> ! 44: #include "pathnames.h" ! 45: ! 46: /* some defines to spec out what our wumpus cave should look like */ ! 47: ! 48: #define MAX_ARROW_SHOT_DISTANCE 6 /* +1 for '0' stopper */ ! 49: #define MAX_LINKS_IN_ROOM 25 /* a complex cave */ ! 50: ! 51: #define MAX_ROOMS_IN_CAVE 250 ! 52: #define ROOMS_IN_CAVE 20 ! 53: #define MIN_ROOMS_IN_CAVE 10 ! 54: ! 55: #define LINKS_IN_ROOM 3 ! 56: #define NUMBER_OF_ARROWS 5 ! 57: #define PIT_COUNT 3 ! 58: #define BAT_COUNT 3 ! 59: ! 60: #define EASY 1 /* levels of play */ ! 61: #define HARD 2 ! 62: ! 63: /* some macro definitions for cleaner output */ ! 64: ! 65: #define plural(n) (n == 1 ? "" : "s") ! 66: ! 67: /* simple cave data structure; +1 so we can index from '1' not '0' */ ! 68: struct room_record { ! 69: int tunnel[MAX_LINKS_IN_ROOM]; ! 70: int has_a_pit, has_a_bat; ! 71: } cave[MAX_ROOMS_IN_CAVE+1]; ! 72: ! 73: /* ! 74: * global variables so we can keep track of where the player is, how ! 75: * many arrows they still have, where el wumpo is, and so on... ! 76: */ ! 77: int player_loc = -1; /* player location */ ! 78: int wumpus_loc = -1; /* The Bad Guy location */ ! 79: int level = EASY; /* level of play */ ! 80: int arrows_left; /* arrows unshot */ ! 81: ! 82: #ifdef DEBUG ! 83: int debug = 0; ! 84: #endif ! 85: ! 86: int pit_num = PIT_COUNT; /* # pits in cave */ ! 87: int bat_num = BAT_COUNT; /* # bats */ ! 88: int room_num = ROOMS_IN_CAVE; /* # rooms in cave */ ! 89: int link_num = LINKS_IN_ROOM; /* links per room */ ! 90: int arrow_num = NUMBER_OF_ARROWS; /* arrow inventory */ ! 91: ! 92: char answer[20]; /* user input */ ! 93: ! 94: main(argc, argv) ! 95: int argc; ! 96: char **argv; ! 97: { ! 98: extern char *optarg; ! 99: int c; ! 100: ! 101: #ifdef DEBUG ! 102: while ((c = getopt(argc, argv, "a:b:hp:r:t:d")) != EOF) ! 103: #else ! 104: while ((c = getopt(argc, argv, "a:b:hp:r:t:")) != EOF) ! 105: #endif ! 106: switch (c) { ! 107: case 'a': ! 108: arrow_num = atoi(optarg); ! 109: break; ! 110: case 'b': ! 111: bat_num = atoi(optarg); ! 112: break; ! 113: #ifdef DEBUG ! 114: case 'd': ! 115: debug = 1; ! 116: break; ! 117: #endif ! 118: case 'h': ! 119: level = HARD; ! 120: break; ! 121: case 'p': ! 122: pit_num = atoi(optarg); ! 123: break; ! 124: case 'r': ! 125: room_num = atoi(optarg); ! 126: if (room_num < MIN_ROOMS_IN_CAVE) { ! 127: (void)fprintf(stderr, ! 128: "No self-respecting wumpus would live in such a small cave!\n"); ! 129: exit(1); ! 130: } ! 131: if (room_num > MAX_ROOMS_IN_CAVE) { ! 132: (void)fprintf(stderr, ! 133: "Even wumpii can't furnish caves that large!\n"); ! 134: exit(1); ! 135: } ! 136: break; ! 137: case 't': ! 138: link_num = atoi(optarg); ! 139: if (link_num < 2) { ! 140: (void)fprintf(stderr, ! 141: "Wumpii like extra doors in their caves!\n"); ! 142: exit(1); ! 143: } ! 144: break; ! 145: case '?': ! 146: default: ! 147: usage(); ! 148: } ! 149: ! 150: if (link_num > MAX_LINKS_IN_ROOM || ! 151: link_num > room_num - (room_num / 4)) { ! 152: (void)fprintf(stderr, ! 153: "Too many tunnels! The cave collapsed!\n(Fortunately, the wumpus escaped!)\n"); ! 154: exit(1); ! 155: } ! 156: ! 157: if (level == HARD) { ! 158: bat_num += ((random() % (room_num / 2)) + 1); ! 159: pit_num += ((random() % (room_num / 2)) + 1); ! 160: } ! 161: ! 162: if (bat_num > room_num / 2) { ! 163: (void)fprintf(stderr, ! 164: "The wumpus refused to enter the cave, claiming it was too crowded!\n"); ! 165: exit(1); ! 166: } ! 167: ! 168: if (pit_num > room_num / 2) { ! 169: (void)fprintf(stderr, ! 170: "The wumpus refused to enter the cave, claiming it was too dangerous!\n"); ! 171: exit(1); ! 172: } ! 173: ! 174: instructions(); ! 175: cave_init(); ! 176: ! 177: /* and we're OFF! da dum, da dum, da dum, da dum... */ ! 178: (void)printf( ! 179: "\nYou're in a cave with %d rooms and %d tunnels leading from each room.\n\ ! 180: There are %d bat%s and %d pit%s scattered throughout the cave, and your\n\ ! 181: quiver holds %d custom super anti-evil Wumpus arrows. Good luck.\n", ! 182: room_num, link_num, bat_num, plural(bat_num), pit_num, ! 183: plural(pit_num), arrow_num); ! 184: ! 185: for (;;) { ! 186: initialize_things_in_cave(); ! 187: arrows_left = arrow_num; ! 188: do { ! 189: display_room_stats(); ! 190: (void)printf("Move or shoot? (m-s) "); ! 191: (void)fflush(stdout); ! 192: if (!fgets(answer, sizeof(answer), stdin)) ! 193: break; ! 194: } while (!take_action()); ! 195: ! 196: if (!getans("\nCare to play another game? (y-n) ")) ! 197: exit(0); ! 198: if (getans("In the same cave? (y-n) ")) ! 199: clear_things_in_cave(); ! 200: else ! 201: cave_init(); ! 202: } ! 203: /* NOTREACHED */ ! 204: } ! 205: ! 206: display_room_stats() ! 207: { ! 208: register int i; ! 209: ! 210: /* ! 211: * Routine will explain what's going on with the current room, as well ! 212: * as describe whether there are pits, bats, & wumpii nearby. It's ! 213: * all pretty mindless, really. ! 214: */ ! 215: (void)printf( ! 216: "\nYou are in room %d of the cave, and have %d arrow%s left.\n", ! 217: player_loc, arrows_left, plural(arrows_left)); ! 218: ! 219: if (bats_nearby()) ! 220: (void)printf("*rustle* *rustle* (must be bats nearby)\n"); ! 221: if (pit_nearby()) ! 222: (void)printf("*whoosh* (I feel a draft from some pits).\n"); ! 223: if (wump_nearby()) ! 224: (void)printf("*sniff* (I can smell the evil Wumpus nearby!)\n"); ! 225: ! 226: (void)printf("There are tunnels to rooms %d, ", ! 227: cave[player_loc].tunnel[0]); ! 228: ! 229: for (i = 1; i < link_num - 1; i++) ! 230: if (cave[player_loc].tunnel[i] <= room_num) ! 231: (void)printf("%d, ", cave[player_loc].tunnel[i]); ! 232: (void)printf("and %d.\n", cave[player_loc].tunnel[link_num - 1]); ! 233: } ! 234: ! 235: take_action() ! 236: { ! 237: /* ! 238: * Do the action specified by the player, either 'm'ove, 's'hoot ! 239: * or something exceptionally bizarre and strange! Returns 1 ! 240: * iff the player died during this turn, otherwise returns 0. ! 241: */ ! 242: switch (*answer) { ! 243: case 'M': ! 244: case 'm': /* move */ ! 245: return(move_to(answer + 1)); ! 246: case 'S': ! 247: case 's': /* shoot */ ! 248: return(shoot(answer + 1)); ! 249: case 'Q': ! 250: case 'q': ! 251: case 'x': ! 252: exit(0); ! 253: case '\n': ! 254: return(0); ! 255: } ! 256: if (random() % 15 == 1) ! 257: (void)printf("Que pasa?\n"); ! 258: else ! 259: (void)printf("I don't understand!\n"); ! 260: return(0); ! 261: } ! 262: ! 263: move_to(room_number) ! 264: char *room_number; ! 265: { ! 266: int i, just_moved_by_bats, next_room, tunnel_available; ! 267: ! 268: /* ! 269: * This is responsible for moving the player into another room in the ! 270: * cave as per their directions. If room_number is a null string, ! 271: * then we'll prompt the user for the next room to go into. Once ! 272: * we've moved into the room, we'll check for things like bats, pits, ! 273: * and so on. This routine returns 1 if something occurs that kills ! 274: * the player and 0 otherwise... ! 275: */ ! 276: tunnel_available = just_moved_by_bats = 0; ! 277: next_room = atoi(room_number); ! 278: ! 279: /* crap for magic tunnels */ ! 280: if (next_room == room_num + 1 && ! 281: cave[player_loc].tunnel[link_num-1] != next_room) ! 282: ++next_room; ! 283: ! 284: while (next_room < 1 || next_room > room_num + 1) { ! 285: if (next_room < 0 && next_room != -1) ! 286: (void)printf("Sorry, but we're constrained to a semi-Euclidean cave!\n"); ! 287: if (next_room > room_num + 1) ! 288: (void)printf("What? The cave surely isn't quite that big!\n"); ! 289: if (next_room == room_num + 1 && ! 290: cave[player_loc].tunnel[link_num-1] != next_room) { ! 291: (void)printf("What? The cave isn't that big!\n"); ! 292: ++next_room; ! 293: } ! 294: (void)printf("To which room do you wish to move? "); ! 295: (void)fflush(stdout); ! 296: if (!fgets(answer, sizeof(answer), stdin)) ! 297: return(1); ! 298: next_room = atoi(answer); ! 299: } ! 300: ! 301: /* now let's see if we can move to that room or not */ ! 302: tunnel_available = 0; ! 303: for (i = 0; i < link_num; i++) ! 304: if (cave[player_loc].tunnel[i] == next_room) ! 305: tunnel_available = 1; ! 306: ! 307: if (!tunnel_available) { ! 308: (void)printf("*Oof!* (You hit the wall)\n"); ! 309: if (random() % 6 == 1) { ! 310: (void)printf("Your colorful comments awaken the wumpus!\n"); ! 311: move_wump(); ! 312: if (wumpus_loc == player_loc) { ! 313: wump_kill(); ! 314: return(1); ! 315: } ! 316: } ! 317: return(0); ! 318: } ! 319: ! 320: /* now let's move into that room and check it out for dangers */ ! 321: if (next_room == room_num + 1) ! 322: jump(next_room = (random() % room_num) + 1); ! 323: ! 324: player_loc = next_room; ! 325: for (;;) { ! 326: if (next_room == wumpus_loc) { /* uh oh... */ ! 327: wump_kill(); ! 328: return(1); ! 329: } ! 330: if (cave[next_room].has_a_pit) ! 331: if (random() % 12 < 2) { ! 332: pit_survive(); ! 333: return(0); ! 334: } else { ! 335: pit_kill(); ! 336: return(1); ! 337: } ! 338: ! 339: if (cave[next_room].has_a_bat) { ! 340: (void)printf( ! 341: "*flap* *flap* *flap* (humongous bats pick you up and move you%s!)\n", ! 342: just_moved_by_bats ? " again": ""); ! 343: next_room = player_loc = (random() % room_num) + 1; ! 344: just_moved_by_bats = 1; ! 345: } ! 346: ! 347: else ! 348: break; ! 349: } ! 350: return(0); ! 351: } ! 352: ! 353: shoot(room_list) ! 354: char *room_list; ! 355: { ! 356: int chance, next, roomcnt; ! 357: int j, arrow_location, link, ok; ! 358: char *p, *strtok(); ! 359: ! 360: /* ! 361: * Implement shooting arrows. Arrows are shot by the player indicating ! 362: * a space-separated list of rooms that the arrow should pass through; ! 363: * if any of the rooms they specify are not accessible via tunnel from ! 364: * the room the arrow is in, it will instead fly randomly into another ! 365: * room. If the player hits the wumpus, this routine will indicate ! 366: * such. If it misses, this routine will *move* the wumpus one room. ! 367: * If it's the last arrow, the player then dies... Returns 1 if the ! 368: * player has won or died, 0 if nothing has happened. ! 369: */ ! 370: arrow_location = player_loc; ! 371: for (roomcnt = 1;; ++roomcnt, room_list = NULL) { ! 372: if (!(p = strtok(room_list, " \t\n"))) ! 373: if (roomcnt == 1) { ! 374: (void)printf( ! 375: "The arrow falls to the ground at your feet!\n"); ! 376: return(0); ! 377: } else ! 378: break; ! 379: if (roomcnt > 5) { ! 380: (void)printf( ! 381: "The arrow wavers in its flight and and can go no further!\n"); ! 382: break; ! 383: } ! 384: next = atoi(p); ! 385: for (j = 0, ok = 0; j < link_num; j++) ! 386: if (cave[arrow_location].tunnel[j] == next) ! 387: ok = 1; ! 388: ! 389: if (ok) { ! 390: if (next > room_num) { ! 391: (void)printf( ! 392: "A faint gleam tells you the arrow has gone through a magic tunnel!\n"); ! 393: arrow_location = (random() % room_num) + 1; ! 394: } else ! 395: arrow_location = next; ! 396: } else { ! 397: link = (random() % link_num); ! 398: if (link == player_loc) ! 399: (void)printf( ! 400: "*thunk* The arrow can't find a way from %d to %d and flys back into\n\ ! 401: your room!\n", ! 402: arrow_location, next); ! 403: else if (cave[arrow_location].tunnel[link] > room_num) ! 404: (void)printf( ! 405: "*thunk* The arrow flys randomly into a magic tunnel, thence into\n\ ! 406: room %d!\n", ! 407: cave[arrow_location].tunnel[link]); ! 408: else ! 409: (void)printf( ! 410: "*thunk* The arrow can't find a way from %d to %d and flys randomly\n\ ! 411: into room %d!\n", ! 412: arrow_location, next, ! 413: cave[arrow_location].tunnel[link]); ! 414: arrow_location = cave[arrow_location].tunnel[link]; ! 415: break; ! 416: } ! 417: chance = random() % 10; ! 418: if (roomcnt == 3 && chance < 2) { ! 419: (void)printf( ! 420: "Your bowstring breaks! *twaaaaaang*\n\ ! 421: The arrow is weakly shot and can go no further!\n"); ! 422: break; ! 423: } else if (roomcnt == 4 && chance < 6) { ! 424: (void)printf( ! 425: "The arrow wavers in its flight and and can go no further!\n"); ! 426: break; ! 427: } ! 428: } ! 429: ! 430: /* ! 431: * now we've gotten into the new room let us see if El Wumpo is ! 432: * in the same room ... if so we've a HIT and the player WON! ! 433: */ ! 434: if (arrow_location == wumpus_loc) { ! 435: kill_wump(); ! 436: return(1); ! 437: } ! 438: ! 439: if (arrow_location == player_loc) { ! 440: shoot_self(); ! 441: return(1); ! 442: } ! 443: ! 444: if (!--arrows_left) { ! 445: no_arrows(); ! 446: return(1); ! 447: } ! 448: ! 449: { ! 450: /* each time you shoot, it's more likely the wumpus moves */ ! 451: static int lastchance = 2; ! 452: ! 453: if (random() % level == EASY ? 12 : 9 < (lastchance += 2)) { ! 454: move_wump(); ! 455: if (wumpus_loc == player_loc) ! 456: wump_kill(); ! 457: lastchance = random() % 3; ! 458: ! 459: } ! 460: } ! 461: return(0); ! 462: } ! 463: ! 464: cave_init() ! 465: { ! 466: register int i, j, k, link; ! 467: int delta, int_compare(); ! 468: time_t time(); ! 469: ! 470: /* ! 471: * This does most of the interesting work in this program actually! ! 472: * In this routine we'll initialize the Wumpus cave to have all rooms ! 473: * linking to all others by stepping through our data structure once, ! 474: * recording all forward links and backwards links too. The parallel ! 475: * "linkcount" data structure ensures that no room ends up with more ! 476: * than three links, regardless of the quality of the random number ! 477: * generator that we're using. ! 478: */ ! 479: srandom((int)time((time_t *)0)); ! 480: ! 481: /* initialize the cave first off. */ ! 482: for (i = 1; i <= room_num; ++i) ! 483: for (j = 0; j < link_num ; ++j) ! 484: cave[i].tunnel[j] = -1; ! 485: ! 486: /* choose a random 'hop' delta for our guaranteed link */ ! 487: while (!(delta = random() % room_num)); ! 488: ! 489: for (i = 1; i <= room_num; ++i) { ! 490: link = ((i + delta) % room_num) + 1; /* connection */ ! 491: cave[i].tunnel[0] = link; /* forw link */ ! 492: cave[link].tunnel[1] = i; /* back link */ ! 493: } ! 494: /* now fill in the rest of the cave with random connections */ ! 495: for (i = 1; i <= room_num; i++) ! 496: for (j = 2; j < link_num ; j++) { ! 497: if (cave[i].tunnel[j] != -1) ! 498: continue; ! 499: try_again: link = (random() % room_num) + 1; ! 500: /* skip duplicates */ ! 501: for (k = 0; k < j; k++) ! 502: if (cave[i].tunnel[k] == link) ! 503: goto try_again; ! 504: cave[i].tunnel[j] = link; ! 505: if (random() % 2 == 1) ! 506: continue; ! 507: for (k = 0; k < link_num; ++k) { ! 508: /* if duplicate, skip it */ ! 509: if (cave[link].tunnel[k] == i) ! 510: k = link_num; ! 511: ! 512: /* if open link, use it, force exit */ ! 513: if (cave[link].tunnel[k] == -1) { ! 514: cave[link].tunnel[k] = i; ! 515: k = link_num; ! 516: } ! 517: } ! 518: } ! 519: /* ! 520: * now that we're done, sort the tunnels in each of the rooms to ! 521: * make it easier on the intrepid adventurer. ! 522: */ ! 523: for (i = 1; i <= room_num; ++i) ! 524: qsort(cave[i].tunnel, (u_int)link_num, ! 525: sizeof(cave[i].tunnel[0]), int_compare); ! 526: ! 527: #ifdef DEBUG ! 528: if (debug) ! 529: for (i = 1; i <= room_num; ++i) { ! 530: (void)printf("<room %d has tunnels to ", i); ! 531: for (j = 0; j < link_num; ++j) ! 532: (void)printf("%d ", cave[i].tunnel[j]); ! 533: (void)printf(">\n"); ! 534: } ! 535: #endif ! 536: } ! 537: ! 538: clear_things_in_cave() ! 539: { ! 540: register int i; ! 541: ! 542: /* ! 543: * remove bats and pits from the current cave in preparation for us ! 544: * adding new ones via the initialize_things_in_cave() routines. ! 545: */ ! 546: for (i = 1; i <= room_num; ++i) ! 547: cave[i].has_a_bat = cave[i].has_a_pit = 0; ! 548: } ! 549: ! 550: initialize_things_in_cave() ! 551: { ! 552: register int i, loc; ! 553: ! 554: /* place some bats, pits, the wumpus, and the player. */ ! 555: for (i = 0; i < bat_num; ++i) { ! 556: do { ! 557: loc = (random() % room_num) + 1; ! 558: } while (cave[loc].has_a_bat); ! 559: cave[loc].has_a_bat = 1; ! 560: #ifdef DEBUG ! 561: if (debug) ! 562: (void)printf("<bat in room %d>\n", loc); ! 563: #endif ! 564: } ! 565: ! 566: for (i = 0; i < pit_num; ++i) { ! 567: do { ! 568: loc = (random() % room_num) + 1; ! 569: } while (cave[loc].has_a_pit && cave[loc].has_a_bat); ! 570: cave[loc].has_a_pit = 1; ! 571: #ifdef DEBUG ! 572: if (debug) ! 573: (void)printf("<pit in room %d>\n", loc); ! 574: #endif ! 575: } ! 576: ! 577: wumpus_loc = (random() % room_num) + 1; ! 578: #ifdef DEBUG ! 579: if (debug) ! 580: (void)printf("<wumpus in room %d>\n", loc); ! 581: #endif ! 582: ! 583: do { ! 584: player_loc = (random() % room_num) + 1; ! 585: } while (player_loc == wumpus_loc || (level == HARD ? ! 586: (link_num / room_num < 0.4 ? wump_nearby() : 0) : 0)); ! 587: } ! 588: ! 589: getans(prompt) ! 590: char *prompt; ! 591: { ! 592: char buf[20]; ! 593: ! 594: /* ! 595: * simple routine to ask the yes/no question specified until the user ! 596: * answers yes or no, then return 1 if they said 'yes' and 0 if they ! 597: * answered 'no'. ! 598: */ ! 599: for (;;) { ! 600: (void)printf("%s", prompt); ! 601: (void)fflush(stdout); ! 602: if (!fgets(buf, sizeof(buf), stdin)) ! 603: return(0); ! 604: if (*buf == 'N' || *buf == 'n') ! 605: return(0); ! 606: if (*buf == 'Y' || *buf == 'y') ! 607: return(1); ! 608: (void)printf( ! 609: "I don't understand your answer; please enter 'y' or 'n'!\n"); ! 610: } ! 611: /* NOTREACHED */ ! 612: } ! 613: ! 614: bats_nearby() ! 615: { ! 616: register int i; ! 617: ! 618: /* check for bats in the immediate vicinity */ ! 619: for (i = 0; i < link_num; ++i) ! 620: if (cave[cave[player_loc].tunnel[i]].has_a_bat) ! 621: return(1); ! 622: return(0); ! 623: } ! 624: ! 625: pit_nearby() ! 626: { ! 627: register int i; ! 628: ! 629: /* check for pits in the immediate vicinity */ ! 630: for (i = 0; i < link_num; ++i) ! 631: if (cave[cave[player_loc].tunnel[i]].has_a_pit) ! 632: return(1); ! 633: return(0); ! 634: } ! 635: ! 636: wump_nearby() ! 637: { ! 638: register int i, j; ! 639: ! 640: /* check for a wumpus within TWO caves of where we are */ ! 641: for (i = 0; i < link_num; ++i) { ! 642: if (cave[player_loc].tunnel[i] == wumpus_loc) ! 643: return(1); ! 644: for (j = 0; j < link_num; ++j) ! 645: if (cave[cave[player_loc].tunnel[i]].tunnel[j] == ! 646: wumpus_loc) ! 647: return(1); ! 648: } ! 649: return(0); ! 650: } ! 651: ! 652: move_wump() ! 653: { ! 654: wumpus_loc = cave[wumpus_loc].tunnel[random() % link_num]; ! 655: } ! 656: ! 657: int_compare(a, b) ! 658: int *a, *b; ! 659: { ! 660: return(*a < *b ? -1 : 1); ! 661: } ! 662: ! 663: instructions() ! 664: { ! 665: char buf[120], *p, *getenv(); ! 666: ! 667: /* ! 668: * read the instructions file, if needed, and show the user how to ! 669: * play this game! ! 670: */ ! 671: if (!getans("Instructions? (y-n) ")) ! 672: return; ! 673: ! 674: if (access(_PATH_WUMPINFO, R_OK)) { ! 675: (void)printf( ! 676: "Sorry, but the instruction file seems to have disappeared in a\n\ ! 677: puff of greasy black smoke! (poof)\n"); ! 678: return; ! 679: } ! 680: ! 681: if (!(p = getenv("PAGER")) || ! 682: strlen(p) > sizeof(buf) + strlen(_PATH_WUMPINFO) + 5) ! 683: p = _PATH_PAGER; ! 684: ! 685: (void)sprintf(buf, "%s %s", p, _PATH_WUMPINFO); ! 686: (void)system(buf); ! 687: } ! 688: ! 689: usage() ! 690: { ! 691: (void)fprintf(stderr, ! 692: "usage: wump [-h] [-a arrows] [-b bats] [-p pits] [-r rooms] [-t tunnels]\n"); ! 693: exit(1); ! 694: } ! 695: ! 696: /* messages */ ! 697: ! 698: wump_kill() ! 699: { ! 700: (void)printf( ! 701: "*ROAR* *chomp* *snurfle* *chomp*!\n\ ! 702: Much to the delight of the Wumpus, you walked right into his mouth,\n\ ! 703: making you one of the easiest dinners he's ever had! For you, however,\n\ ! 704: it's a rather unpleasant death. The only good thing is that it's been\n\ ! 705: so long since the evil Wumpus cleaned his teeth that you immediately\n\ ! 706: passed out from the stench!\n"); ! 707: } ! 708: ! 709: kill_wump() ! 710: { ! 711: (void)printf( ! 712: "*thwock!* *groan* *crash*\n\n\ ! 713: A horrible roar fills the cave, and you realize, with a smile, that you\n\ ! 714: have slain the evil Wumpus and won the game! You don't want to tarry for\n\ ! 715: long, however, because not only is the Wumpus famous, but the stench of\n\ ! 716: dead Wumpus is also quite well known, a stench plenty enough to slay the\n\ ! 717: mightiest adventurer at a single whiff!!\n"); ! 718: } ! 719: ! 720: no_arrows() ! 721: { ! 722: (void)printf( ! 723: "\nYou turn and look at your quiver, and realize with a sinking feeling\n\ ! 724: that you've just shot your last arrow (figuratively, too). Sensing this\n\ ! 725: with its psychic powers, the evil Wumpus rampagees through the cave, finds\n\ ! 726: you, and with a mighty *ROAR* eats you alive!\n"); ! 727: } ! 728: ! 729: shoot_self() ! 730: { ! 731: (void)printf( ! 732: "\n*Thwack!* A sudden piercing feeling informs you that the ricochet\n\ ! 733: of your wild arrow has resulted in it wedging in your side, causing\n\ ! 734: extreme agony. The evil Wumpus, with its psychic powers, realizes this\n\ ! 735: and immediately rushes to your side, not to help, alas, but to EAT YOU!\n\ ! 736: (*CHOMP*)\n"); ! 737: } ! 738: ! 739: jump(where) ! 740: int where; ! 741: { ! 742: (void)printf( ! 743: "\nWith a jaunty step you enter the magic tunnel. As you do, you\n\ ! 744: notice that the walls are shimmering and glowing. Suddenly you feel\n\ ! 745: a very curious, warm sensation and find yourself in room %d!!\n", where); ! 746: } ! 747: ! 748: pit_kill() ! 749: { ! 750: (void)printf( ! 751: "*AAAUUUUGGGGGHHHHHhhhhhhhhhh...*\n\ ! 752: The whistling sound and updraft as you walked into this room of the\n\ ! 753: cave apparently wasn't enough to clue you in to the presence of the\n\ ! 754: bottomless pit. You have a lot of time to reflect on this error as\n\ ! 755: you fall many miles to the core of the earth. Look on the bright side;\n\ ! 756: you can at least find out if Jules Verne was right...\n"); ! 757: } ! 758: ! 759: pit_survive() ! 760: { ! 761: (void)printf( ! 762: "Without conscious thought you grab for the side of the cave and manage\n\ ! 763: to grasp onto a rocky outcrop. Beneath your feet stretches the limitless\n\ ! 764: depths of a bottomless pit! Rock crumbles beneath your feet!\n"); ! 765: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.