Games/wumpus/wumpus.c

   1 /*
   2  * wumpus.c --- a faithful translation of the classic "Hunt The Wumpus" game.
   3  *
   4  * Translator: Eric S. Raymond <esr@snark.thyrsus.com>
   5  * Version: $Id$
   6  *
   7  * This was the state of the art 20 years ago, in 1972.  We've come a long
   8  * way, baby.
   9  *
  10  * The BASIC source is that posted by Magnus Olsson in USENET article
  11  * <9207071854.AA21847@thep.lu.se>: he wrote
  12  *
  13  * >Below is the source code for _one_ (rather simple) Wumpus version,
  14  * >which I found in the PC-BLUE collection on SIMTEL20. I believe this is
  15  * >pretty much the same version that was published in David Ahl's "101
  16  * >Basic Computer Games" (or, possibly, in the sequel).
  17  *
  18  * I have staunchly resisted the temptation to "improve" this game.  It
  19  * is functionally identical to the BASIC version (source for which
  20  * appears in the comments).  I fixed some typos in the help text.
  21  *
  22  * Language hackers may be interested to know that he most difficult thing
  23  * about the translation was tracking the details required to translate from
  24  * 1-origin to 0-origin array indexing.
  25  *
  26  * The only enhancement is a an -s command-line switch for setting the
  27  * random number seed.
  28  *
  29  * So, pretend for a little while that your workstation is an ASR-33 and
  30  * limber up your fingers for a trip to nostalgia-land...
  31  */
  32
  33 #include <stdio.h>
  34 /* Changes for AROS - JP */
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <time.h>
  38 /* End AROS */
  39
  40 /* 5 REM *** HUNT THE WUMPUS ***                    */
  41
  42 /* 10 DIM P(5)                                */
  43 static int path[5];
  44
  45 static int j, k, arrows, scratchloc;
  46 static char inp[BUFSIZ];        /* common input buffer */
  47
  48 #define YOU    0
  49 #define WUMPUS    1
  50 #define PIT1    2
  51 #define PIT2    3
  52 #define BATS1    4
  53 #define BATS2    5
  54 #define LOCS    6
  55 static int loc[LOCS], save[LOCS];    /* locations */
  56
  57 #define NOT    0
  58 #define WIN    1
  59 #define LOSE    -1
  60 static int finished;
  61
  62 /* 80 REM *** SET UP CAVE (DODECAHEDRAL NODE LIST) ***        */
  63 /* 85 DIM S(20,3)                            */
  64 /* 90 FOR J=1 TO 20                            */
  65 /* 95 FOR K=1 TO 3                            */
  66 /* 100 READ S(J,K)                            */
  67 /* 105 NEXT K                            */
  68 /* 110 NEXT J                            */
  69 /* 115 DATA 2,5,8,1,3,10,2,4,12,3,5,14,1,4,6            */
  70 /* 120 DATA 5,7,15,6,8,17,1,7,9,8,10,18,2,9,11            */
  71 /* 125 DATA 10,12,19,3,11,13,12,14,20,4,13,15,6,14,16        */
  72 /* 130 DATA 15,17,20,7,16,18,9,17,19,11,18,20,13,16,19        */
  73 static int cave[20][3] =
  74 {
  75     {1,4,7},
  76     {0,2,9},
  77     {1,3,11},
  78     {2,4,13},
  79     {0,3,5},
  80     {4,6,14},
  81     {5,7,16},
  82     {0,6,8},
  83     {7,9,17},
  84     {1,8,10},
  85     {9,11,18},
  86     {2,10,12},
  87     {11,13,19},
  88     {3,12,14},
  89     {5,13,15},
  90     {14,16,19},
  91     {6,15,17},
  92     {8,16,18},
  93     {10,17,19},
  94     {12,15,18},
  95 };
  96
  97 /* 135 DEF FNA(X)=INT(20*RND(1))+1                    */
  98 #define FNA() (rand() % 20)
  99
 100 /* 140 DEF FNB(X)=INT(3*RND(1))+1                    */
 101 #define FNB() (rand() % 3)
 102
 103 /* 145 DEF FNC(X)=INT(4*RND(1))+1                    */
 104 #define FNC() (rand() % 4)
 105
 106 int getnum(prompt)
 107 char *prompt;
 108 {
 109     (void) printf("%s\n?", prompt);
 110     (void) fgets(inp, sizeof(inp), stdin);
 111     return(atoi(inp));
 112 }
 113
 114 int getlet(prompt)
 115 char *prompt;
 116 {
 117     (void) printf("%s\n?", prompt);
 118     (void) fgets(inp, sizeof(inp), stdin);
 119     return(inp[0]);
 120 }
 121
 122 void print_instructions()
 123 {
 124 /* not used, commented out to make gcc happy */
 125 /*    char ebuf[BUFSIZ]; */
 126
 127 /* 375 REM *** INSTRUCTIONS ***                        */
 128 /* 380 PRINT "WELCOME TO 'HUNT THE WUMPUS'"                */
 129     puts("WELCOME TO 'HUNT THE WUMPUS'");
 130 /* 385 PRINT "  THE WUMPUS LIVES IN A CAVE OF 20 ROOMS. EACH ROOM"    */
 131     puts("  THE WUMPUS LIVES IN A CAVE OF 20 ROOMS. EACH ROOM");
 132 /* 390 PRINT "HAS 3 TUNNELS LEADING TO OTHER ROOMS. (LOOK AT A"        */
 133     puts("HAS 3 TUNNELS LEADING TO OTHER ROOMS. (LOOK AT A");
 134 /* 395 PRINT "DODECAHEDRON TO SEE HOW THIS WORKS-IF YOU DON'T KNOW"    */
 135     puts("DODECAHEDRON TO SEE HOW THIS WORKS-IF YOU DON'T KNOW");
 136 /* 400 PRINT "WHAT A DODECAHEDRON IS, ASK SOMEONE)"            */
 137     puts("WHAT A DODECAHEDRON IS, ASK SOMEONE)");
 138 /* 405 PRINT                                */
 139     puts("");
 140 /* 410 PRINT "     HAZARDS:"                        */
 141     puts("     HAZARDS:");
 142 /* 415 PRINT " BOTTOMLESS PITS - TWO ROOMS HAVE BOTTOMLESS PITS IN THEM
 143  */
 144     puts(" BOTTOMLESS PITS - TWO ROOMS HAVE BOTTOMLESS PITS IN THEM");
 145 /* 420 PRINT "     IF YOU GO THERE, YOU FALL INTO THE PIT (& LOSE!)"    */
 146     puts("     IF YOU GO THERE, YOU FALL INTO THE PIT (& LOSE!)");
 147 /* 425 PRINT " SUPER BATS - TWO OTHER ROOMS HAVE SUPER BATS. IF YOU"    */
 148     puts(" SUPER BATS - TWO OTHER ROOMS HAVE SUPER BATS. IF YOU");
 149 /* 430 PRINT "     GO THERE, A BAT GRABS YOU AND TAKES YOU TO SOME OTHER"
 150    */
 151     puts("     GO THERE, A BAT GRABS YOU AND TAKES YOU TO SOME OTHER");
 152 /* 435 PRINT "     ROOM AT RANDOM. (WHICH MAY BE TROUBLESOME)"        */
 153     puts("     ROOM AT RANDOM. (WHICH MAY BE TROUBLESOME)");
 154 /* 440 INPUT "TYPE AN E THEN RETURN ";W9                */
 155     (void) getlet("TYPE AN E THEN RETURN ");
 156 /* 445 PRINT "     WUMPUS:"                        */
 157     puts("     WUMPUS:");
 158 /* 450 PRINT " THE WUMPUS IS NOT BOTHERED BY HAZARDS (HE HAS SUCKER"    */
 159     puts(" THE WUMPUS IS NOT BOTHERED BY HAZARDS (HE HAS SUCKER");
 160 /* 455 PRINT " FEET AND IS TOO BIG FOR A BAT TO LIFT).  USUALLY"    */
 161     puts(" FEET AND IS TOO BIG FOR A BAT TO LIFT).  USUALLY");
 162 /* 460 PRINT " HE IS ASLEEP.  TWO THINGS WAKE HIM UP: YOU SHOOTING AN"    */
 163     puts(" HE IS ASLEEP.  TWO THINGS WAKE HIM UP: YOU SHOOTING AN");
 164 /* 465 PRINT "ARROW OR YOU ENTERING HIS ROOM."                */
 165     puts("ARROW OR YOU ENTERING HIS ROOM.");
 166 /* 470 PRINT "     IF THE WUMPUS WAKES HE MOVES (P=.75) ONE ROOM"    */
 167     puts("     IF THE WUMPUS WAKES HE MOVES (P=.75) ONE ROOM");
 168 /* 475 PRINT " OR STAYS STILL (P=.25).  AFTER THAT, IF HE IS WHERE YOU"
 169  */
 170     puts(" OR STAYS STILL (P=.25).  AFTER THAT, IF HE IS WHERE YOU");
 171 /* 480 PRINT " ARE, HE EATS YOU UP AND YOU LOSE!"            */
 172     puts(" ARE, HE EATS YOU UP AND YOU LOSE!");
 173 /* 485 PRINT                                */
 174     puts("");
 175 /* 490 PRINT "     YOU:"                        */
 176     puts("     YOU:");
 177 /* 495 PRINT " EACH TURN YOU MAY MOVE OR SHOOT A CROOKED ARROW"        */
 178     puts(" EACH TURN YOU MAY MOVE OR SHOOT A CROOKED ARROW");
 179 /* 500 PRINT "   MOVING:  YOU CAN MOVE ONE ROOM (THRU ONE TUNNEL)"    */
 180     puts("   MOVING:  YOU CAN MOVE ONE ROOM (THRU ONE TUNNEL)");
 181 /* 505 PRINT "   ARROWS:  YOU HAVE 5 ARROWS.  YOU LOSE WHEN YOU RUN OUT
 182  */
 183     puts("   ARROWS:  YOU HAVE 5 ARROWS.  YOU LOSE WHEN YOU RUN OUT");
 184 /* 510 PRINT "   EACH ARROW CAN GO FROM 1 TO 5 ROOMS. YOU AIM BY TELLING*/
 185     puts("   EACH ARROW CAN GO FROM 1 TO 5 ROOMS. YOU AIM BY TELLING");
 186 /* 515 PRINT "   THE COMPUTER THE ROOM#S YOU WANT THE ARROW TO GO TO."    */
 187     puts("   THE COMPUTER THE ROOM#S YOU WANT THE ARROW TO GO TO.");
 188 /* 520 PRINT "   IF THE ARROW CAN'T GO THAT WAY (IF NO TUNNEL) IT MOVES"*/
 189     puts("   IF THE ARROW CAN'T GO THAT WAY (IF NO TUNNEL) IT MOVES");
 190 /* 525 PRINT "   AT RANDOM TO THE NEXT ROOM."                */
 191     puts("   AT RANDOM TO THE NEXT ROOM.");
 192 /* 530 PRINT "     IF THE ARROW HITS THE WUMPUS, YOU WIN."        */
 193     puts("     IF THE ARROW HITS THE WUMPUS, YOU WIN.");
 194 /* 535 PRINT "     IF THE ARROW HITS YOU, YOU LOSE."            */
 195     puts("     IF THE ARROW HITS YOU, YOU LOSE.");
 196 /* 540 INPUT "TYPE AN E THEN RETURN ";W9                */
 197     (void) getlet("TYPE AN E THEN RETURN ");
 198 /* 545 PRINT "    WARNINGS:"                        */
 199     puts("    WARNINGS:");
 200 /* 550 PRINT "     WHEN YOU ARE ONE ROOM AWAY FROM A WUMPUS OR HAZARD,"
 201  */
 202     puts("     WHEN YOU ARE ONE ROOM AWAY FROM A WUMPUS OR HAZARD,");
 203 /* 555 PRINT "     THE COMPUTER SAYS:"                    */
 204     puts("     THE COMPUTER SAYS:");
 205 /* 560 PRINT " WUMPUS:  'I SMELL A WUMPUS'"                */
 206     puts(" WUMPUS:  'I SMELL A WUMPUS'");
 207 /* 565 PRINT " BAT   :  'BATS NEARBY'"                    */
 208     puts(" BAT   :  'BATS NEARBY'");
 209 /* 570 PRINT " PIT   :  'I FEEL A DRAFT'"                */
 210     puts(" PIT   :  'I FEEL A DRAFT'");
 211 /* 575 PRINT                                */
 212     puts("");
 213 /* 580 RETURN                                */
 214 }
 215
 216 void check_hazards()
 217 {
 218     /* 585 REM *** PRINT LOCATION & HAZARD WARNINGS ***            */
 219     /* 590 PRINT                            */
 220     (void) puts("");
 221
 222     /* 595 FOR J=2 TO 6                            */
 223     /* 600 FOR K=1 TO 3                            */
 224     /* 605 IF S(L(1),K)<>L(J) THEN 640                    */
 225     /* 610 ON J-1 GOTO 615,625,625,635,635                */
 226     /* 615 PRINT "I SMELL A WUMPUS!"                    */
 227     /* 620 GOTO 640                            */
 228     /* 625 PRINT "I FEEL A DRAFT"                    */
 229     /* 630 GOTO 640                            */
 230     /* 635 PRINT "BATS NEARBY!"                        */
 231     /* 640 NEXT K                            */
 232     /* 645 NEXT J                            */
 233     for (k = 0; k < 3; k++)
 234     {
 235     int room = cave[loc[YOU]][k];
 236
 237     if (room == loc[WUMPUS])
 238         (void) puts("I SMELL A WUMPUS!");
 239     else if (room == loc[PIT1] || room == loc[PIT2])
 240         (void) puts("I FEEL A DRAFT");
 241     else if (room == loc[BATS1] || room == loc[BATS2])
 242         (void) puts("BATS NEARBY!");
 243     }
 244
 245     /* 650 PRINT "YOU ARE IN ROOM "L(1)                    */
 246     (void) printf("YOU ARE IN ROOM %d\n", loc[YOU]+1);
 247
 248     /* 655 PRINT "TUNNELS LEAD TO "S(L,1);S(L,2);S(L,3)            */
 249     (void) printf("TUNNELS LEAD TO %d %d %d\n",
 250           cave[loc[YOU]][0]+1, cave[loc[YOU]][1]+1, cave[loc[YOU]][2]+1);
 251
 252     /* 660 PRINT                            */
 253     (void) puts("");
 254
 255     /* 665 RETURN                            */
 256 }
 257
 258 int move_or_shoot()
 259 {
 260     int c;
 261
 262     /* 670 REM *** CHOOSE OPTION ***                    */
 263
 264 badin:
 265     /* 675 PRINT "SHOOT OR MOVE (S-M)";                    */
 266     /* 680 INPUT I$                            */
 267     c = getlet("SHOOT OR MOVE (S-M)");
 268
 269     /* 685 IF I$<>"S" THEN 700                        */
 270     /* 690 O=1                                */
 271     /* 695 RETURN                            */
 272     /* 700 IF I$<>"M" THEN 675                        */
 273     /* 705 O=2                                */
 274     /* 710 RETURN                            */
 275     if (c == 'S')
 276     return(1);
 277     else if (c == 'M')
 278     return(0);
 279     else
 280     goto badin;
 281 }
 282
 283
 284
 285 void shoot()
 286 {
 287     extern void check_shot(), move_wumpus();
 288     int    j9;
 289
 290     /* 715 REM *** ARROW ROUTINE ***                    */
 291     /* 720 F=0                                */
 292     finished = NOT;
 293
 294     /* 725 REM *** PATH OF ARROW ***                    */
 295 badrange:
 296     /* 735 PRINT "NO. OF ROOMS (1-5)";                    */
 297     /* 740 INPUT J9                            */
 298     j9 = getnum("NO. OF ROOMS (1-5)");
 299
 300     /* 745 IF J9<1 THEN 735                        */
 301     /* 750 IF J9>5 THEN 735                        */
 302     if (j9 < 1 || j9 > 5)
 303     goto badrange;
 304
 305     /* 755 FOR K=1 TO J9                        */
 306     for (k = 0; k < j9; k++)
 307     {
 308     /* 760 PRINT "ROOM #";                        */
 309     /* 765 INPUT P(K)                        */
 310     path[k] = getnum("ROOM #") - 1;
 311
 312     /* 770 IF K<=2 THEN 790                        */
 313     if (k <= 1)
 314         continue;
 315
 316     /* 775 IF P(K)<>P(K-2) THEN 790                    */
 317     if (path[k] != path[k - 2])
 318         continue;
 319
 320     /* 780 PRINT "ARROWS AREN'T THAT CROOKED - TRY ANOTHER ROOM"    */
 321     (void) puts("ARROWS AREN'T THAT CROOKED - TRY ANOTHER ROOM");
 322     /* 785 GOTO 760                            */
 323     k--;
 324
 325     /* 790 NEXT K                            */
 326     }
 327
 328     /* 795 REM *** SHOOT ARROW ***                    */
 329     /* 800 L=L(1)                            */
 330     scratchloc = loc[YOU];
 331
 332     /* 805 FOR K=1 TO J9                        */
 333     for (k = 0; k < j9; k++)
 334     {
 335     int    k1;
 336
 337     /* 810 FOR K1=1 TO 3                        */
 338     for (k1 = 0; k1 < 3; k1++)
 339     {
 340         /* 815 IF S(L,K1)=P(K) THEN 895                */
 341         if (cave[scratchloc][k1] == path[k])
 342         {
 343         /*
 344          * This is the only bit of the translation I'm not sure
 345          * about.  It requires the trajectory of the arrow to
 346          * be a path.  Without it, all rooms on the trajectory
 347          * would be required by the above to be adjacent to the
 348          * player, making for a trivial game --- just move to where
 349          * you smell a wumpus and shoot into all adjacent passages!
 350          * However, I can't find an equivalent in the BASIC.
 351          */
 352         scratchloc = path[k];
 353
 354         /* this simulates logic at 895 in the BASIC code */
 355         check_shot();
 356         if (finished != NOT)
 357             return;
 358         }
 359
 360         /* 820 NEXT K1                        */
 361     }
 362
 363     /* 825 REM *** NO TUNNEL FOR ARROW ***                */
 364     /* 830 L=S(L,FNB(1))                        */
 365     scratchloc = cave[scratchloc][FNB()];
 366
 367     /* 835 GOTO 900                            */
 368     check_shot();
 369
 370     /* 840 NEXT K                            */
 371     }
 372 /* This label is not used, silence gcc */
 373 /* ammo: */
 374     if (finished == NOT)
 375     {
 376     /* 845 PRINT "MISSED"                        */
 377     (void) puts("MISSED");
 378
 379     /* 850 L=L(1)                            */
 380     scratchloc = loc[YOU];
 381
 382     /* 855 REM *** MOVE WUMPUS ***                    */
 383     /* 860 GOSUB 935                        */
 384     move_wumpus();
 385
 386     /* 865 REM *** AMMO CHECK ***                    */
 387     /* 870 A=A-1                            */
 388     /* 875 IF A>0 THEN 885                        */
 389     /* 880 F=-1                            */
 390     if (--arrows <= 0)
 391         finished = LOSE;
 392     }
 393
 394     /* 885 RETURN                            */
 395 }
 396
 397 void check_shot()
 398 {
 399     /* 890 REM *** SEE IF ARROW IS AT L(1) OR AT L(2)            */
 400     /* 895 L=P(K)                            */
 401
 402     /* 900 IF L<>L(2) THEN 920                        */
 403     /* 905 PRINT "AHA! YOU GOT THE WUMPUS!"                */
 404     /* 910 F=1                                */
 405     /* 915 RETURN                            */
 406     if (scratchloc == loc[WUMPUS])
 407     {
 408     (void) puts("AHA! YOU GOT THE WUMPUS!");
 409     finished = WIN;
 410     }
 411
 412     /* 920 IF L<>L(1) THEN 840                        */
 413     /* 925 PRINT "OUCH! ARROW GOT YOU!"                    */
 414     /* 930 GOTO 880                            */
 415     else if (scratchloc == loc[YOU])
 416     {
 417     (void) puts("OUCH! ARROW GOT YOU!");
 418     finished = LOSE;
 419     }
 420 }
 421
 422 void move_wumpus()
 423 {
 424     /* 935 REM *** MOVE WUMPUS ROUTINE ***                */
 425     /* 940 K=FNC(0)                            */
 426     k = FNC();
 427
 428     /* 945 IF K=4 THEN 955                        */
 429     /* 950 L(2)=S(L(2),K)                        */
 430     if (k < 3)
 431     loc[WUMPUS] = cave[loc[WUMPUS]][k];
 432
 433     /* 955 IF L(2)<>L THEN 970                        */
 434     if (loc[WUMPUS] != loc[YOU])
 435     return;
 436
 437     /* 960 PRINT "TSK TSK TSK - WUMPUS GOT YOU!"            */
 438     (void) puts("TSK TSK TSK - WUMPUS GOT YOU!");
 439
 440     /* 965 F=-1                                */
 441     finished = LOSE;
 442
 443     /* 970 RETURN                            */
 444 }
 445
 446 void move()
 447 {
 448     /* 975 REM *** MOVE ROUTINE ***                    */
 449     /* 980 F=0                                */
 450     finished = NOT;
 451
 452 badmove:
 453     /* 985 PRINT "WHERE TO";                        */
 454     /* 990 INPUT L                            */
 455     scratchloc = getnum("WHERE TO");
 456
 457     /* 995 IF L<1 THEN 985                        */
 458     /* 1000 IF L>20 THEN 985                        */
 459     if (scratchloc < 1 || scratchloc > 20)
 460     goto badmove;
 461     scratchloc--;
 462
 463     /* 1005 FOR K=1 TO 3                        */
 464     for (k = 0; k < 3; k++)
 465     {
 466     /* 1010 REM *** CHECK IF LEGAL MOVE ***                */
 467     /* 1015 IF S(L(1),K)=L THEN 1045                */
 468     if (cave[loc[YOU]][k] == scratchloc)
 469         goto goodmove;
 470
 471     /* 1020 NEXT K                            */
 472     }
 473
 474     /* 1025 IF L=L(1) THEN 1045                        */
 475     if (scratchloc != loc[YOU])
 476     {
 477     /* 1030 PRINT "NOT POSSIBLE -";                    */
 478     (void) puts("NOT POSSIBLE -");
 479
 480     /* 1035 GOTO 985                        */
 481     goto badmove;
 482     }
 483
 484 goodmove:
 485     /* 1040 REM *** CHECK FOR HAZARDS ***                */
 486     /* 1045 L(1)=L                            */
 487     loc[YOU] = scratchloc;
 488
 489     if (scratchloc == loc[WUMPUS])
 490     {
 491     /* 1050 REM *** WUMPUS ***                    */
 492     /* 1055 IF L<>L(2) THEN 1090                    */
 493     /* 1060 PRINT "... OOPS! BUMPED A WUMPUS!"            */
 494     /* 1065 REM *** MOVE WUMPUS ***                    */
 495     /* 1070 GOSUB 940                        */
 496     /* 1075 IF F=0 THEN 1090                    */
 497     /* 1080 RETURN                            */
 498     (void) puts("... OOPS! BUMPED A WUMPUS!");
 499     move_wumpus();
 500     }
 501     else if (scratchloc == loc[PIT1] || scratchloc == loc[PIT2])
 502     {
 503     /* 1085 REM *** PIT ***                        */
 504     /* 1090 IF L=L(3) THEN 1100                    */
 505     /* 1095 IF L<>L(4) THEN 1120                    */
 506     /* 1100 PRINT "YYYYIIIIEEEE . . . FELL IN PIT"            */
 507     /* 1105 F=-1                            */
 508     /* 1110 RETURN                            */
 509     (void) puts("YYYYIIIIEEEE . . . FELL IN PIT");
 510     finished = LOSE;
 511     }
 512     else if (scratchloc == loc[BATS1] || scratchloc == loc[BATS2])
 513     {
 514     /* 1115 REM *** BATS ***                    */
 515     /* 1120 IF L=L(5) THEN 1130                    */
 516     /* 1125 IF L<>L(6) THEN 1145                    */
 517     /* 1130 PRINT "ZAP--SUPER BAT SNATCH! ELSEWHEREVILLE FOR YOU!"    */
 518     /* 1135 L=FNA(1)                        */
 519     /* 1140 GOTO 1045                        */
 520     /* 1145 RETURN                            */
 521     /* 1150 END                            */
 522     (void) puts("ZAP--SUPER BAT SNATCH! ELSEWHEREVILLE FOR YOU!");
 523     scratchloc = loc[YOU] = FNA();
 524     goto goodmove;
 525     }
 526 }
 527
 528 int main(argc, argv)
 529 int argc;
 530 char *argv[];
 531 {
 532     int    c;
 533
 534     if (argc >= 2 && strcmp(argv[1], "-s") == 0)
 535     srand(atoi(argv[2]));
 536     else
 537     srand((int)time((long *) 0));
 538
 539     /* 15 PRINT "INSTRUCTIONS (Y-N)";                    */
 540     /* 20 INPUT I$                            */
 541     c = getlet("INSTRUCTIONS (Y-N)");
 542
 543     /* 25 IF I$="N" THEN 35                        */
 544     /* 30 GOSUB 375                            */
 545     /* 35 GOTO 80                            */
 546     if (c == 'Y')
 547     print_instructions();
 548
 549     /* 150 REM *** LOCATE L ARRAY ITEMS ***                */
 550     /* 155 REM *** 1-YOU, 2-WUMPUS, 3&4-PITS, 5&6-BATS ***        */
 551     /* 160 DIM L(6)                            */
 552     /* 165 DIM M(6)                            */
 553 badlocs:
 554     /* 170 FOR J=1 TO 6                            */
 555     /* 175 L(J)=FNA(0)                            */
 556     /* 180 M(J)=L(J)                            */
 557     /* 185 NEXT J                            */
 558     for (j = 0; j < LOCS; j++)
 559     loc[j] = save[j] = FNA();
 560
 561     /* 190 REM *** CHECK FOR CROSSOVERS (IE L(1)=L(2), ETC) ***        */
 562     /* 195 FOR J=1 TO 6                            */
 563     /* 200 FOR K=1 TO 6                            */
 564     /* 205 IF J=K THEN 215                        */
 565     /* 210 IF L(J)=L(K) THEN 170                    */
 566     /* 215 NEXT K                            */
 567     /* 220 NEXT J                            */
 568     for (j = 0; j < LOCS; j++)
 569     for (k = 0; k < LOCS; k++)
 570         if (j == k)
 571         continue;
 572             else if (loc[j] == loc[k])
 573         goto badlocs;
 574
 575     /* 225 REM *** SET NO. OF ARROWS ***                */
 576 newgame:
 577     /* 230 A=5                                */
 578     /* 235 L=L(1)                            */
 579     arrows = 5;
 580     scratchloc = loc[YOU];
 581
 582     /* 240 REM *** RUN THE GAME ***                    */
 583     /* 245 PRINT "HUNT THE WUMPUS"                    */
 584     (void) puts("HUNT THE WUMPUS");
 585
 586 #ifdef DEBUG
 587     (void) printf("Wumpus is at %d, pits at %d & %d, bats at %d & %d\n",
 588           loc[WUMPUS]+1,
 589           loc[PIT1]+1, loc[PIT2]+1,
 590           loc[BATS1]+1, loc[BATS2]+1);
 591 #endif
 592
 593 nextmove:
 594     /* 250 REM *** HAZARD WARNING AND LOCATION ***            */
 595     /* 255 GOSUB 585                            */
 596     check_hazards();
 597
 598     /* 260 REM *** MOVE OR SHOOT ***                    */
 599     /* 265 GOSUB 670                            */
 600     /* 270 ON O GOTO 280,300                        */
 601     if (move_or_shoot())
 602     {
 603     /* 275 REM *** SHOOT ***                    */
 604     /* 280 GOSUB 715                        */
 605     shoot();
 606
 607     /* 285 IF F=0 THEN 255                        */
 608     if (finished == NOT)
 609         goto nextmove;
 610
 611     /* 290 GOTO 310                            */
 612     }
 613     else
 614     {
 615     /* 295 REM *** MOVE ***                        */
 616     /* 300 GOSUB 975                        */
 617     move();
 618
 619     /* 305 IF F=0 THEN 255                        */
 620     if (finished == NOT)
 621         goto nextmove;
 622     }
 623
 624     /* 310 IF F>0 THEN 335                        */
 625     if (finished == LOSE)
 626     {
 627     /* 315 REM *** LOSE ***                        */
 628     /* 320 PRINT "HA HA HA - YOU LOSE!"                */
 629     /* 325 GOTO 340                            */
 630     (void) puts("HA HA HA - YOU LOSE!");
 631     }
 632     else
 633     {
 634     /* 330 REM *** WIN ***                        */
 635     /* 335 PRINT "HEE HEE HEE - THE WUMPUS'LL GET YOU NEXT TIME!!"    */
 636     (void) puts("HEE HEE HEE - THE WUMPUS'LL GET YOU NEXT TIME!!");
 637     }
 638
 639     /* 340 FOR J=1 TO 6                            */
 640     /* 345 L(J)=M(J)                            */
 641     /* 350 NEXT J                            */
 642     for (j = YOU; j < LOCS; j++)
 643     loc[j] = save[j];
 644
 645     /* 355 PRINT "SAME SETUP (Y-N)";                    */
 646     /* 360 INPUT I$                            */
 647     c = getlet("SAME SETUP (Y-N)");
 648
 649     /* 365 IF I$<>"Y"THEN 170                        */
 650     /* 370 GOTO 230                            */
 651     if (c != 'Y')
 652     goto badlocs;
 653     else
 654     goto newgame;
 655 }
 656
 657 /* wumpus.c ends here */
 658