Fix some more the the typos.
[dragonfly.git] / 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. 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 }