games/wump/wump.c

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