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