Merge commit 'origin/vendor/PAM_PASSWDQC'
[games.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. 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.6 2007/04/18 18:32:12 swildner 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(void)
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(void)
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(char *room_number)
305 {
306         int i, just_moved_by_bats, next_room, tunnel_available;
307
308         /*
309          * This is responsible for moving the player into another room in the
310          * cave as per their directions.  If room_number is a null string,
311          * then we'll prompt the user for the next room to go into.   Once
312          * we've moved into the room, we'll check for things like bats, pits,
313          * and so on.  This routine returns 1 if something occurs that kills
314          * the player and 0 otherwise...
315          */
316         tunnel_available = just_moved_by_bats = 0;
317         next_room = atoi(room_number);
318
319         /* crap for magic tunnels */
320         if (next_room == room_num + 1 &&
321             cave[player_loc].tunnel[link_num-1] != next_room)
322                 ++next_room;
323
324         while (next_room < 1 || next_room > room_num + 1) {
325                 if (next_room < 0 && next_room != -1)
326 (void)printf("Sorry, but we're constrained to a semi-Euclidean cave!\n");
327                 if (next_room > room_num + 1)
328 (void)printf("What?  The cave surely isn't quite that big!\n");
329                 if (next_room == room_num + 1 &&
330                     cave[player_loc].tunnel[link_num-1] != next_room) {
331                         (void)printf("What?  The cave isn't that big!\n");
332                         ++next_room;
333                 }
334                 (void)printf("To which room do you wish to move? ");
335                 (void)fflush(stdout);
336                 if (!fgets(answer, sizeof(answer), stdin))
337                         return(1);
338                 next_room = atoi(answer);
339         }
340
341         /* now let's see if we can move to that room or not */
342         tunnel_available = 0;
343         for (i = 0; i < link_num; i++)
344                 if (cave[player_loc].tunnel[i] == next_room)
345                         tunnel_available = 1;
346
347         if (!tunnel_available) {
348                 (void)printf("*Oof!*  (You hit the wall)\n");
349                 if (random() % 6 == 1) {
350 (void)printf("Your colorful comments awaken the wumpus!\n");
351                         move_wump();
352                         if (wumpus_loc == player_loc) {
353                                 wump_kill();
354                                 return(1);
355                         }
356                 }
357                 return(0);
358         }
359
360         /* now let's move into that room and check it out for dangers */
361         if (next_room == room_num + 1)
362                 jump(next_room = (random() % room_num) + 1);
363
364         player_loc = next_room;
365         for (;;) {
366                 if (next_room == wumpus_loc) {          /* uh oh... */
367                         wump_kill();
368                         return(1);
369                 }
370                 if (cave[next_room].has_a_pit) {
371                         if (random() % 12 < 2) {
372                                 pit_survive();
373                                 return(0);
374                         } else {
375                                 pit_kill();
376                                 return(1);
377                         }
378                 }
379
380                 if (cave[next_room].has_a_bat) {
381                         (void)printf(
382 "*flap*  *flap*  *flap*  (humongous bats pick you up and move you%s!)\n",
383                             just_moved_by_bats ? " again": "");
384                         next_room = player_loc = (random() % room_num) + 1;
385                         just_moved_by_bats = 1;
386                 }
387
388                 else
389                         break;
390         }
391         return(0);
392 }
393
394 int
395 shoot(char *room_list)
396 {
397         int chance, next, roomcnt;
398         int j, arrow_location, wumplink, ok;
399         char *p;
400
401         /*
402          * Implement shooting arrows.  Arrows are shot by the player indicating
403          * a space-separated list of rooms that the arrow should pass through;
404          * if any of the rooms they specify are not accessible via tunnel from
405          * the room the arrow is in, it will instead fly randomly into another
406          * room.  If the player hits the wumpus, this routine will indicate
407          * such.  If it misses, this routine will *move* the wumpus one room.
408          * If it's the last arrow, the player then dies...  Returns 1 if the
409          * player has won or died, 0 if nothing has happened.
410          */
411         arrow_location = player_loc;
412         for (roomcnt = 1;; ++roomcnt, room_list = NULL) {
413                 if (!(p = strtok(room_list, " \t\n"))) {
414                         if (roomcnt == 1) {
415                                 (void)printf(
416                         "The arrow falls to the ground at your feet!\n");
417                                 return(0);
418                         } else
419                                 break;
420                 }
421                 if (roomcnt > 5)  {
422                         (void)printf(
423 "The arrow wavers in its flight and and can go no further!\n");
424                         break;
425                 }
426                 next = atoi(p);
427                 for (j = 0, ok = 0; j < link_num; j++)
428                         if (cave[arrow_location].tunnel[j] == next)
429                                 ok = 1;
430
431                 if (ok) {
432                         if (next > room_num) {
433                                 (void)printf(
434 "A faint gleam tells you the arrow has gone through a magic tunnel!\n");
435                                 arrow_location = (random() % room_num) + 1;
436                         } else
437                                 arrow_location = next;
438                 } else {
439                         wumplink = (random() % link_num);
440                         if (wumplink == player_loc)
441                                 (void)printf(
442 "*thunk*  The arrow can't find a way from %d to %d and flys back into\n\
443 your room!\n",
444                                     arrow_location, next);
445                         else if (cave[arrow_location].tunnel[wumplink] > room_num)
446                                 (void)printf(
447 "*thunk*  The arrow flys randomly into a magic tunnel, thence into\n\
448 room %d!\n",
449                                     cave[arrow_location].tunnel[wumplink]);
450                         else
451                                 (void)printf(
452 "*thunk*  The arrow can't find a way from %d to %d and flys randomly\n\
453 into room %d!\n",
454                                     arrow_location, next,
455                                     cave[arrow_location].tunnel[wumplink]);
456                         arrow_location = cave[arrow_location].tunnel[wumplink];
457                         break;
458                 }
459                 chance = random() % 10;
460                 if (roomcnt == 3 && chance < 2) {
461                         (void)printf(
462 "Your bowstring breaks!  *twaaaaaang*\n\
463 The arrow is weakly shot and can go no further!\n");
464                         break;
465                 } else if (roomcnt == 4 && chance < 6) {
466                         (void)printf(
467 "The arrow wavers in its flight and and can go no further!\n");
468                         break;
469                 }
470         }
471
472         /*
473          * now we've gotten into the new room let us see if El Wumpo is
474          * in the same room ... if so we've a HIT and the player WON!
475          */
476         if (arrow_location == wumpus_loc) {
477                 kill_wump();
478                 return(1);
479         }
480
481         if (arrow_location == player_loc) {
482                 shoot_self();
483                 return(1);
484         }
485
486         if (!--arrows_left) {
487                 no_arrows();
488                 return(1);
489         }
490
491         {
492                 /* each time you shoot, it's more likely the wumpus moves */
493                 static int lastchance = 2;
494
495                 if (random() % level == EASY ? 12 : 9 < (lastchance += 2)) {
496                         move_wump();
497                         if (wumpus_loc == player_loc)
498                                 wump_kill();
499                         lastchance = random() % 3;
500
501                 }
502         }
503         return(0);
504 }
505
506 void
507 cave_init(void)
508 {
509         int i, j, k, wumplink;
510         int delta;
511
512         /*
513          * This does most of the interesting work in this program actually!
514          * In this routine we'll initialize the Wumpus cave to have all rooms
515          * linking to all others by stepping through our data structure once,
516          * recording all forward links and backwards links too.  The parallel
517          * "linkcount" data structure ensures that no room ends up with more
518          * than three links, regardless of the quality of the random number
519          * generator that we're using.
520          */
521         srandomdev();
522
523         /* initialize the cave first off. */
524         for (i = 1; i <= room_num; ++i)
525                 for (j = 0; j < link_num ; ++j)
526                         cave[i].tunnel[j] = -1;
527
528         /* choose a random 'hop' delta for our guaranteed link */
529         while (!(delta = random() % room_num));
530
531         for (i = 1; i <= room_num; ++i) {
532                 wumplink = ((i + delta) % room_num) + 1;        /* connection */
533                 cave[i].tunnel[0] = wumplink;                   /* forw link */
534                 cave[wumplink].tunnel[1] = i;                   /* back link */
535         }
536         /* now fill in the rest of the cave with random connections */
537         for (i = 1; i <= room_num; i++)
538                 for (j = 2; j < link_num ; j++) {
539                         if (cave[i].tunnel[j] != -1)
540                                 continue;
541 try_again:              wumplink = (random() % room_num) + 1;
542                         /* skip duplicates */
543                         for (k = 0; k < j; k++)
544                                 if (cave[i].tunnel[k] == wumplink)
545                                         goto try_again;
546                         cave[i].tunnel[j] = wumplink;
547                         if (random() % 2 == 1)
548                                 continue;
549                         for (k = 0; k < link_num; ++k) {
550                                 /* if duplicate, skip it */
551                                 if (cave[wumplink].tunnel[k] == i)
552                                         k = link_num;
553
554                                 /* if open link, use it, force exit */
555                                 if (cave[wumplink].tunnel[k] == -1) {
556                                         cave[wumplink].tunnel[k] = i;
557                                         k = link_num;
558                                 }
559                         }
560                 }
561         /*
562          * now that we're done, sort the tunnels in each of the rooms to
563          * make it easier on the intrepid adventurer.
564          */
565         for (i = 1; i <= room_num; ++i)
566                 qsort(cave[i].tunnel, (u_int)link_num,
567                     sizeof(cave[i].tunnel[0]), int_compare);
568
569 #ifdef DEBUG
570         if (debug)
571                 for (i = 1; i <= room_num; ++i) {
572                         (void)printf("<room %d  has tunnels to ", i);
573                         for (j = 0; j < link_num; ++j)
574                                 (void)printf("%d ", cave[i].tunnel[j]);
575                         (void)printf(">\n");
576                 }
577 #endif
578 }
579
580 void
581 clear_things_in_cave(void)
582 {
583         int i;
584
585         /*
586          * remove bats and pits from the current cave in preparation for us
587          * adding new ones via the initialize_things_in_cave() routines.
588          */
589         for (i = 1; i <= room_num; ++i)
590                 cave[i].has_a_bat = cave[i].has_a_pit = 0;
591 }
592
593 void
594 initialize_things_in_cave(void)
595 {
596         int i, loc;
597
598         /* place some bats, pits, the wumpus, and the player. */
599         for (i = 0; i < bat_num; ++i) {
600                 do {
601                         loc = (random() % room_num) + 1;
602                 } while (cave[loc].has_a_bat);
603                 cave[loc].has_a_bat = 1;
604 #ifdef DEBUG
605                 if (debug)
606                         (void)printf("<bat in room %d>\n", loc);
607 #endif
608         }
609
610         for (i = 0; i < pit_num; ++i) {
611                 do {
612                         loc = (random() % room_num) + 1;
613                 } while (cave[loc].has_a_pit && cave[loc].has_a_bat);
614                 cave[loc].has_a_pit = 1;
615 #ifdef DEBUG
616                 if (debug)
617                         (void)printf("<pit in room %d>\n", loc);
618 #endif
619         }
620
621         wumpus_loc = (random() % room_num) + 1;
622 #ifdef DEBUG
623         if (debug)
624                 (void)printf("<wumpus in room %d>\n", loc);
625 #endif
626
627         do {
628                 player_loc = (random() % room_num) + 1;
629         } while (player_loc == wumpus_loc || (level == HARD ?
630             (link_num / room_num < 0.4 ? wump_nearby() : 0) : 0));
631 }
632
633 int
634 getans(const char *prompt)
635 {
636         char buf[20];
637
638         /*
639          * simple routine to ask the yes/no question specified until the user
640          * answers yes or no, then return 1 if they said 'yes' and 0 if they
641          * answered 'no'.
642          */
643         for (;;) {
644                 (void)printf("%s", prompt);
645                 (void)fflush(stdout);
646                 if (!fgets(buf, sizeof(buf), stdin))
647                         return(0);
648                 if (*buf == 'N' || *buf == 'n')
649                         return(0);
650                 if (*buf == 'Y' || *buf == 'y')
651                         return(1);
652                 (void)printf(
653 "I don't understand your answer; please enter 'y' or 'n'!\n");
654         }
655         /* NOTREACHED */
656 }
657
658 int
659 bats_nearby(void)
660 {
661         int i;
662
663         /* check for bats in the immediate vicinity */
664         for (i = 0; i < link_num; ++i)
665                 if (cave[cave[player_loc].tunnel[i]].has_a_bat)
666                         return(1);
667         return(0);
668 }
669
670 int
671 pit_nearby(void)
672 {
673         int i;
674
675         /* check for pits in the immediate vicinity */
676         for (i = 0; i < link_num; ++i)
677                 if (cave[cave[player_loc].tunnel[i]].has_a_pit)
678                         return(1);
679         return(0);
680 }
681
682 int
683 wump_nearby(void)
684 {
685         int i, j;
686
687         /* check for a wumpus within TWO caves of where we are */
688         for (i = 0; i < link_num; ++i) {
689                 if (cave[player_loc].tunnel[i] == wumpus_loc)
690                         return(1);
691                 for (j = 0; j < link_num; ++j)
692                         if (cave[cave[player_loc].tunnel[i]].tunnel[j] ==
693                             wumpus_loc)
694                                 return(1);
695         }
696         return(0);
697 }
698
699 void
700 move_wump(void)
701 {
702         wumpus_loc = cave[wumpus_loc].tunnel[random() % link_num];
703 }
704
705 int
706 int_compare(const void *va, const void *vb)
707 {
708         const int       *a, *b;
709
710         a = (const int *)va;
711         b = (const int *)vb;
712
713         return(a < b ? -1 : 1);
714 }
715
716 void
717 instructions(void)
718 {
719         const char *pager;
720         pid_t pid;
721         int status;
722         int fd;
723
724         /*
725          * read the instructions file, if needed, and show the user how to
726          * play this game!
727          */
728         if (!getans("Instructions? (y-n) "))
729                 return;
730
731         if (access(_PATH_WUMPINFO, R_OK)) {
732                 (void)printf(
733 "Sorry, but the instruction file seems to have disappeared in a\n\
734 puff of greasy black smoke! (poof)\n");
735                 return;
736         }
737
738         if (!isatty(1))
739                 pager = "cat";
740         else {
741                 if (!(pager = getenv("PAGER")) || (*pager == 0))
742                         pager = _PATH_PAGER;
743         }
744         switch (pid = fork()) {
745         case 0: /* child */
746                 if ((fd = open(_PATH_WUMPINFO, O_RDONLY)) == -1)
747                         err(1, "open %s", _PATH_WUMPINFO);
748                 if (dup2(fd, 0) == -1)
749                         err(1, "dup2");
750                 (void)execl("/bin/sh", "sh", "-c", pager, (char *) NULL);
751                 err(1, "exec sh -c %s", pager);
752         case -1:
753                 err(1, "fork");
754         default:
755                 (void)waitpid(pid, &status, 0);
756                 break;
757         }
758 }
759
760 void
761 usage(void)
762 {
763         (void)fprintf(stderr,
764 "usage: wump [-h] [-a arrows] [-b bats] [-p pits] [-r rooms] [-t tunnels]\n");
765         exit(1);
766 }
767
768 /* messages */
769
770 void
771 wump_kill(void)
772 {
773         (void)printf(
774 "*ROAR* *chomp* *snurfle* *chomp*!\n\
775 Much to the delight of the Wumpus, you walked right into his mouth,\n\
776 making you one of the easiest dinners he's ever had!  For you, however,\n\
777 it's a rather unpleasant death.  The only good thing is that it's been\n\
778 so long since the evil Wumpus cleaned his teeth that you immediately\n\
779 passed out from the stench!\n");
780 }
781
782 void
783 kill_wump(void)
784 {
785         (void)printf(
786 "*thwock!* *groan* *crash*\n\n\
787 A horrible roar fills the cave, and you realize, with a smile, that you\n\
788 have slain the evil Wumpus and won the game!  You don't want to tarry for\n\
789 long, however, because not only is the Wumpus famous, but the stench of\n\
790 dead Wumpus is also quite well known, a stench plenty enough to slay the\n\
791 mightiest adventurer at a single whiff!!\n");
792 }
793
794 void
795 no_arrows(void)
796 {
797         (void)printf(
798 "\nYou turn and look at your quiver, and realize with a sinking feeling\n\
799 that you've just shot your last arrow (figuratively, too).  Sensing this\n\
800 with its psychic powers, the evil Wumpus rampagees through the cave, finds\n\
801 you, and with a mighty *ROAR* eats you alive!\n");
802 }
803
804 void
805 shoot_self(void)
806 {
807         (void)printf(
808 "\n*Thwack!*  A sudden piercing feeling informs you that the ricochet\n\
809 of your wild arrow has resulted in it wedging in your side, causing\n\
810 extreme agony.  The evil Wumpus, with its psychic powers, realizes this\n\
811 and immediately rushes to your side, not to help, alas, but to EAT YOU!\n\
812 (*CHOMP*)\n");
813 }
814
815 void
816 jump(int where)
817 {
818         (void)printf(
819 "\nWith a jaunty step you enter the magic tunnel.  As you do, you\n\
820 notice that the walls are shimmering and glowing.  Suddenly you feel\n\
821 a very curious, warm sensation and find yourself in room %d!!\n", where);
822 }
823
824 void
825 pit_kill(void)
826 {
827         (void)printf(
828 "*AAAUUUUGGGGGHHHHHhhhhhhhhhh...*\n\
829 The whistling sound and updraft as you walked into this room of the\n\
830 cave apparently wasn't enough to clue you in to the presence of the\n\
831 bottomless pit.  You have a lot of time to reflect on this error as\n\
832 you fall many miles to the core of the earth.  Look on the bright side;\n\
833 you can at least find out if Jules Verne was right...\n");
834 }
835
836 void
837 pit_survive(void)
838 {
839         (void)printf(
840 "Without conscious thought you grab for the side of the cave and manage\n\
841 to grasp onto a rocky outcrop.  Beneath your feet stretches the limitless\n\
842 depths of a bottomless pit!  Rock crumbles beneath your feet!\n");
843 }