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