V10/games/adv/adv.c
/* Adventure (3/6/79 17:32:41 1.20)
Current limits:
999 lines, linsiz of message text (lines).
750 travel options (travel, trvsiz).
300 vocabulary words (ktab, atab, tabsiz).
150 locations (ltext, stext, key, cond, abb, atloc, locsiz).
100 objects (plac, place, fixd, fixed, rlink (twice), ptext,
prop).
35 "action" verbs (actspk, vrbsiz).
205 random messages (rtext, rtxsiz).
12 different player classifications (ctext, cval, clsmax).
20 hints, less 3 (hintlc, hinted, hints, hntsiz).
35 magic messages (mtext, magsiz).
there are also limits which cannot be exceeded due to the
structure of the database. (e.g., the vocabulary uses
n/1000 to determine word type, so there can't be more
than 1000 words.) these upper limits are:
1000 non-synonymous vocabulary words
300 locations
100 objects
*/
#include <stdio.h>
#include <signal.h>
long longabs(x)
long x;
{
return x<0? -x: x;
}
long getl (file)
register FILE *file;
{
long l;
l = getw (file);
l <<= 16;
l |= getw (file);
return l;
}
putl (l, file)
long l;
register FILE *file;
{
putw ((int) (l >> 16), file);
putw ((int) l, file);
}
FILE *caves, *suspfd;
long tvec, xtime, time();
long ftell();
struct passwd *pwbuf;
char suspbeg; /* Start of variables to write during suspension */
char tkword[10];
char wd2x[5];
char wd2[5];
char wd1x[5];
char wd1[5];
char atab[300+1][6];
char linebuf[100]; /* For reading cave description, etc */
char chr;
char *cp1, *cp2;
int rtext[205];
long newloc = 0L;
long lines[1000]; /* Assumed initialized to zero */
int blklin = 1;
int dseen[6];
int odloc[6];
int dloc[6];
int tk[20+1];
int hinted[20+1];
int hinted[20+1]; /* Assumed initialized to 0 */
int hints[12+1][4+1]; /* Assumed initialized to 0 */
int cval[12+1]; /* Assumed initialized to 0 */
int ctext[12+1]; /* Assumed initialized to 0 */
int actspk[35+1]; /* Assumed initialized to 0 */
int prop[100+1]; /* Assumed initialized to 0 */
int fixd[100+1]; /* Assumed initialized to 0 */
int plac[100+1]; /* Assumed initialized to 0 */
int cond[150+1]; /* Assumed initialized to 0 */
int key[150+1]; /* Assumed initialized to 0 */
int stext[150+1]; /* Assumed initialized to 0 */
int ltext[150+1]; /* Assumed initialized to 0 */
long travel[750+1]; /* Assumed initialized to 0 */
int hintlc[21+1]; /* Assumed initialized to zero */
int abb[150+1];
int holdng;
int fixed[100+1];
int place[100+1];
int rlink[200+1];
int atloc[150+1];
int tabsiz = 300;
int ktab[300+1];
int ptext[100+1];
#ifdef INITBUG
int clssiz = 12;
int linsiz = 999;
int vrbsiz = 35;
#endif INITBUG
int trvsiz = 750;
int locsiz = 150;
int rtxsiz = 205;
int clsmax = 12;
int hntsiz = 20;
int wzdark;
int lmwarn;
int closng;
int panic;
int closed;
int gaveup;
int scorng;
int yea;
long ll;
#ifdef unix
#include <pwd.h>
#define GETPWUID() pwbuf=getpwuid(getuid());cp2=pwbuf->pw_dir;while(*cp1++ = *cp2++);cp1--;
#define HOURS "Colossal Cave is always open\n"
#ifndef CAVE
#define CAVE "/usr/games/lib/cave"
#endif CAVE
#define SUSPREAD "r"
#define SUSPWRITE "w"
#endif
#ifdef gcos
#define CLOSED "Colossal Cave is closed weekdays between 8 AM and 6 PM.\n"
#define GETPWUID() if(lmsgrd()<3){printf(CLOSED);return(0);}fprompt("\r\n");
#define HOURS CLOSED
#define CAVE "cc/adve/cave$abracadabra"
#define SUSPREAD "ri"
#define SUSPWRITE "wi"
#endif
#define abbnum ints[0]
#define iy ints[1]
#define axe ints[2]
#define back ints[3]
#define batter ints[4]
#define bear ints[5]
#define bird ints[6]
#define bonus ints[7]
#define bottle ints[8]
#define cage ints[9]
#define cave ints[10]
#define ccode ints[11]
#define ch ints[12]
#define chain ints[13]
#define chasm ints[14]
#define chest ints[15]
#define chloc ints[16]
#define chloc2 ints[17]
#define clam ints[18]
#define clock1 ints[19]
#define clock2 ints[20]
#define clsses ints[21]
#define coins ints[22]
#define daltlc ints[23]
#define detail ints[24]
#define dflag ints[25]
#define dkill ints[26]
#define door ints[27]
#define dprssn ints[28]
#define dragon ints[29]
#define dtotal ints[30]
#define dwarf ints[31]
#define eggs ints[32]
#define emrald ints[33]
#define entrnc ints[34]
#define find ints[35]
#define fissur ints[36]
#define foo ints[37]
#define foobar ints[38]
#define food ints[39]
#define from ints[40]
#define grate ints[41]
#define hint ints[42]
#define hntmax ints[43]
#define i ints[44]
#define inlen ints[45]
#define invent ints[46]
#define iwest ints[47]
#define j ints[48]
#define k ints[49]
#define keys ints[50]
#define kk ints[51]
#define knfloc ints[52]
#define knife ints[53]
#define kq ints[54]
#define k2 ints[55]
#define l ints[56]
#define lamp ints[57]
#define limit ints[58]
#define linuse ints[59]
#define hungup ints[60]
#define loc ints[61]
#define lock ints[62]
#define look ints[63]
#define m ints[64]
#define magzin ints[65]
#define maxdie ints[66]
#define maxtrs ints[67]
#define messag ints[68]
#define mirror ints[69]
#define mxscor ints[70]
#define nugget ints[71]
#define nullx ints[72]
#define numdie ints[73]
#define obj ints[74]
#define oil ints[75]
#define oldlc2 ints[76]
#define oldloc ints[77]
#define oyster ints[78]
#define pearl ints[79]
#define pillow ints[80]
#define plant ints[81]
#define plant2 ints[82]
#define posn ints[83]
#define pyram ints[84]
#define rod ints[85]
#define rod2 ints[86]
#define rug ints[87]
#define say ints[88]
#define score ints[89]
#define sect ints[90]
#define snake ints[91]
#define spices ints[92]
#define spk ints[93]
#define steps ints[94]
#define stick ints[95]
#define tablet ints[96]
#define tabndx ints[97]
#define tally ints[98]
#define tally2 ints[99]
#define temp ints[100]
#define throw ints[101]
#define attack ints[102]
#define tridnt ints[103]
#define troll ints[104]
#define troll2 ints[105]
#define trvs ints[106]
#define turns ints[107]
#define vase ints[108]
#define vend ints[109]
#define verb ints[110]
#define water ints[111]
#define word ints[112]
#define wordend ints[113]
#define wordsize ints[114]
#define wordstrt ints[115]
#define logon ints[116]
#define srel ints[117]
#define slev ints[118]
#define tleft ints[119]
#define tright ints[120]
int ints[121];
char suspend; /* End of variables to write during suspension */
/*
wzdark says whether the loc he's leaving was dark
lmwarn says whether he's been warned about lamp going dim
closng says whether its closing time yet
panic says whether he's found out he's trapped in the cave
closed says whether we're all the way closed
gaveup says whether he exited via "quit"
scorng indicates to the score routine whether we're doing
a "score" command
yea is random yes/no reply
hungup says whether he hung up the phone
*/
sethup()
{
hungup = 1;
signal (SIGHUP, SIG_IGN);
#ifndef INITBUG
signal (SIGINT, SIG_IGN);
signal (SIGQUIT, SIG_IGN);
#endif INITBUG
}
main()
{
char suspfile[100];
static char outbuf[BUFSIZ];
struct passwd *getpwuid();
setbuf(stdout, outbuf);
setbuf(stderr, NULL);
printf ("@(#)Adventure 1.20\n" + 4);
cp1 = suspfile;
GETPWUID();
cp2 = "/adv.susp";
while (*cp1++ = *cp2++);
#ifndef INITBUG
if (signal (SIGINT, SIG_IGN) != SIG_IGN)
signal (SIGINT, sethup);
if (signal (SIGQUIT, sethup) != SIG_IGN)
signal (SIGQUIT, sethup);
#endif INITBUG
if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
signal (SIGHUP, sethup);
#ifdef LOG
logon = 1;
#else
logon = 0;
#endif
if ((caves = fopen (CAVE, "r")) == NULL)
fatal ("Couldn't open cave file\n");
/* Description of the database format:
The data file contains several sections. Each begins
with a line containing a number identifying the section,
and ends with a line containing "-1".
Section 1: long form descriptions. Each line contains a
location number, a tab, and a line of text. The set
of (necessarily adjacent) lines whose numbers are x
form the long description of location x.
Section 2: Short form descriptions. Same format as long
form. Not all places have short descriptions.
Section 3: Travel table. Each line contains a location
number (x), a second location number (y), and a list
of motion numbers (see section 4). Each motion
represents a verb which will go to y if currently at
x. y, in turn, is interpreted as follows: Let
m=y/1000, n=y mod 1000.
If n<=300 it is the location to go to.
If 300<n<=500 n-300 is used in a computed
goto to a section of special
code.
If n>500 message n-500 from section 6
is printed, and he stays
wherever he is.
Meanwhile, m specifies the conditions on the motion.
If m=0 it's unconditional.
If 0<m<100 it is done with m%
probability.
If m=100 unconditional, but forbidden
to dwarves.
If 100<m<=200 he must be carrying object
m-100.
If 200<m<=300 must be carrying or in same
room as m-200.
If 300<m<=400 prop(m mod 100) must NOT be
0.
If 400<m<=500 prop(m mod 100) must NOT be
1.
If 500<m<=600 prop(m mod 100) must NOT be
2, etc.
If the condition (if any) is not met, then the next
DIFFERENT "destination" value is used (unless it
fails to meet ITS conditions, in which case the
next is found, etc.). Typically, the next dest will
be for one of the same verbs, so that its only use is
as the alternate destination for those verbs. For
instance:
15 110022 29 31 34 35 23 43
15 14 29
This says that, from loc 15, any of the verbs 29, 31,
etc., will take him to 22 if he's carrying object 10,
and otherwise will go to 14.
11 303008 49
11 9 50
This says that, from 11, 49 takes him to 8 unless
prop(3)=0, in which case he goes to 9. Verb 50 takes
him to 9 regardless of prop(3).
Section 4: vocabulary. Each line contains a number (n),
a tab, and a five-letter word. Call m=n/1000. If
m=0, then the word is a motion verb for use in
travelling (see section 3). Else, if m=1, the word
is an object. Else, if m=2, the word is an action
verb (such as "carry" or "attack"). Else, if m=3,
the word is a special case verb (such as "dig") and n
mod 1000 is an index into section 6. Objects from 50
to (currently, anyway) 79 are considered treasures
(for pirate, closeout).
Section 5: object descriptions. Each line contains a
number (n), a tab, and a message. If n is from 1 to
100, the message is the "inventory" message for
object n. Otherwise, n should be 000, 100, 200,
etc., and the message should be the description of
the preceding object when its prop value is n/100.
The n/100 is used only to distinguish multiple
messages from multi-line messages; the prop info
actually requires all messages for an object to be
present and consecutive. Properties which produce no
message should be given the message ">$<".
Section 6: arbitrary messages. Same format as sections
1, 2, and 5, except the numbers bear no relation to
anything (except for special verbs in section 4).
Section 7: object locations. Each line contains an
object number and its initial location (zero (or
omitted) if none). If the object is immovable, the
location is followed by a "-1". If it has two
locations (e.g. the grate) the first location is
followed with the second, and the object is assumed
to be immovable.
Section 8: action defaults. Each line contains an
"action-verb" number and the index (in section 6) of
the default message for the verb.
Section 9: liquid assets, etc. Each line contains a
number (n) and up to 20 location numbers. Bit n
(where 0 is the units bit) is set in cond(loc) for
each loc given. The cond bits currently assigned
are:
0 light
1 if bit 2 is on: on for oil, off for
water
2 liquid asset, see bit 1
3 pirate doesn't go here unless
following player
Other bits are used to indicate areas of interest to
"hint" routines:
4 trying to get into cave
5 trying to catch bird
6 trying to deal with snake
7 lost in maze
8 pondering dark room
9 at Witt's end
cond(loc) is set to 2, overriding all other bits, if
loc has forced motion.
Section 10: class messages. Each line contains a number
(n), a tab, and a message describing a classification
of player. The scoring section selects the
appropriate message, where each message is considered
to apply to players whose scores are higher than the
previous n but not higher than this n. Note that
these scores probably change with every modification
(and particularly expansion) of the program.
Section 11: hints. Each line contains a hint number
(corresponding to a cond bit, see section 9), the
number of turns he must be at the right loc(s) before
triggering the hint, the points deducted for taking
the hint, the message number (section 6) of the
question, and the message number of the hint. These
values are stashed in the "hints" array. hntmax is
set to the max hint number (<= hntsiz). Numbers 1-3
are unusable since cond bits are otherwise assigned,
so 2 is used to remember if he's read the clue in the
repository, and 3 is used to remember whether he
asked for instructions (gets more turns, but loses
points).
Section 12: magic messages. Identical to section 6
except put in a separate section for easier
reference. Magic messages are used by the startup,
maintenance mode, and related routines.
Section 0: end of database.
*/
/* Read the database */
printf("Initializing... ");
fflush(stdout);
/*
Clear out the various text-pointer arrays. All text is
stored in array lines; each line is preceded by a word
pointing to the next pointer (i.e. the word following
the end of the line). The pointer is negative if this is
first line of a message. The text-pointer arrays contain
indices of pointer-words in lines. stext(n) is short
description of location n. ltext(n) is long description.
ptext(n) points to message for prop(n)=0. Successive
prop messages are found by chasing pointers. rtext
contains section 6's stuff. ctext(n) points to a
player-class message. mtext is for section 12. we also
clear cond. see description of section 9 for details.
*/
for (i=1; i<=300; i++) {
if (i <= 100) ptext[i] = 0;
if (i <= rtxsiz) rtext[i] = 0;
if (i <= clsmax) ctext[i] = 0;
if (i <= locsiz) {
stext[i]=0;
ltext[i]=0;
cond[i]=0;
}
}
/* key=0; */
linuse=1;
trvs=1;
clsses=1;
/* Start new data section. sect is the section number. */
l1002:
fscanf (caves, "%d", §);
oldloc= -1;
#ifdef INITBUG
fprintf(stderr, "\nSect=%d\n", sect);
#endif INITBUG
switch (sect) {
case 0:
goto l1100; /* (0) */
case 1:
case 2:
case 5:
case 6:
case 10:
goto l1004; /* 1, 2, 5, 6, 10 */
case 3:
goto l1030; /* (3) */
case 4:
goto l1040; /* (4) */
case 7:
goto l1050; /* (7) */
case 8:
goto l1060; /* (8) */
case 9:
goto l1070; /* (9) */
case 11:
goto l1080; /* (11) */
}
bug(9);
/* Sections 1, 2, 5, 6, 10. Read messages and set up pointers. */
l1004:
fscanf (caves, "%d", &loc);
#ifdef INITBUG
fprintf(stderr, "Sect=%d; Loc=%d\n", sect, loc);
#endif INITBUG
while ((chr = getc (caves)) == ' ' || chr == '\t')
;
ungetc (chr, caves);
lines[linuse] = ftell (caves);
fgets (linebuf, sizeof linebuf, caves);
if (loc == -1) goto l1002;
if (loc != oldloc) {
lines[linuse] = -lines[linuse];
if (sect == 10) {
ctext[clsses] = linuse;
cval[clsses] = loc;
clsses++;
}
else if (sect == 6) {
if (loc > rtxsiz) bug(6);
rtext[loc] = linuse;
}
else if (sect == 5) {
if (loc > 0 && loc <= 100) ptext[loc] = linuse;
}
else if (sect == 1) {
ltext[loc] = linuse;
}
else
stext[loc] = linuse;
}
linuse++;
oldloc = loc;
goto l1004;
/*
The stuff for section 3 is encoded here. Each
"from-location" gets a contiguous section of the "travel"
array. Each entry in travel is newloc*1000 + keyword
(from section 4, motion verbs), and is negated if this is
the last entry for this location. key[n] is the index in
travel of the first option at location n.
*/
l1030:
fscanf (caves, "%d\t%ld", &loc, &newloc);
#ifdef INITBUG
fprintf(stderr, "Sect=%d; Loc=%d; newloc=%d\n", sect, loc, newloc);
#endif INITBUG
i = 0;
while ((chr = getc (caves)) != '\n') {
ungetc (chr, caves);
fscanf (caves, "%d", &tk[i++]);
}
if (loc == -1) goto l1002;
if (key[loc])
travel[trvs-1] = -travel[trvs-1];
else
key[loc] = trvs;
for (l=0; l<i; l++) {
travel[trvs] = newloc * 1000L + tk[l];
trvs++;
if (trvs >= trvsiz) bug(3);
}
travel[trvs-1]= -travel[trvs-1];
goto l1030;
/*
Here we read in the vocabulary. ktab[n] is the word
number, atab[n] is the corresponding word. The -1 at the
end of section 4 is left in ktab as an end-marker.
*/
l1040:
for (tabndx = 1; tabndx <= tabsiz; tabndx++) {
char str[6];
fscanf (caves, "%d\t%s", &ktab[tabndx], str);
#ifdef INITBUG
fprintf(stderr, "Sect=%d; k=%d; str=%s\n", sect, ktab[tabndx], str);
#endif INITBUG
while ((chr = getc(caves)) != '\n')
;
cpy (&atab[tabndx][0], str);
if (ktab[tabndx] == -1) goto l1002;
}
bug(4);
/*
Read in the initial locations for each object. Also the
immovability info. plac contains initial locations of
objects. fixd is -1 for immovable objects (including the
snake), or = second loc for two-placed objects.
*/
l1050:
while (fscanf (caves, "%d\t%d\t%d", &obj, &j, &k), obj != -1) {
#ifdef INITBUG
fprintf(stderr, "Sect=%d; obj=%d; plac=%d; fixd=%d\n", sect, obj, j, k);
#endif INITBUG
plac[obj]=j;
fixd[obj]=k;
}
goto l1002;
/* Read default message numbers for action verbs, store in actspk. */
l1060:
while (fscanf (caves, "%d\t%d", &verb, &j), verb != -1) {
#ifdef INITBUG
fprintf(stderr, "Sect=%d; verb=%d; j=%d\n", sect, verb, j);
#endif INITBUG
actspk[verb]=j;
}
goto l1002;
/* Read info about available liquids and other conditions,
store in cond. */
l1070:
while (fscanf (caves, "%d", &k), k != -1) {
#ifdef INITBUG
fprintf(stderr, "Sect=%d; cond=%d\n", sect, k);
#endif INITBUG
i = 0;
while ((chr = getc(caves)) != '\n') {
ungetc(chr, caves);
fscanf (caves, "%d", &i);
if (bitset (i, k)) {
int z;
for (z=0; z<10; z++)
printf ("cond[%d]=%d\n", z, cond[z]);
fatal ("Duplicate bit\n");
}
cond[i] |= (1 << k);
}
}
goto l1002;
/* Read data for hints. */
l1080:
hntmax=0;
while (fscanf (caves, "%d\t%d\t%d\t%d\t%d",
&k, &tk[1], &tk[2], &tk[3], &tk[4]), k != -1) {
#ifdef INITBUG
fprintf(stderr, "Sect=%d; k=%d; tk=[%d,%d,%d,%d]\n",
sect, k, tk[1], tk[2], tk[3], tk[4]);
#endif INITBUG
if (k != 0) {
if (k < 0 || k > hntsiz) bug(7);
for (i=1; i<=4; i++)
hints[k][i]=tk[i];
if (k > hntmax)
hntmax = k;
}
}
goto l1002;
/*
Finish constructing internal data format
Having read in the database, certain things are now
constructed. Props are set to zero. We finish setting
up cond by checking for forced-motion travel entries.
The plac and fixd arrays are used to set up atloc[n] as
the first object at location n, and rlink[obj] as the next
object at the same location as obj. (obj>100 indicates
that fixed[obj-100]=loc; rlink[obj] is still the correct
link to use.) abb is zeroed; it controls whether the
abbreviated description is printed. Counts mod 5 unless
"look" is used.
*/
l1100:
printf("Linking... ");
fflush(stdout);
for (i=1; i<=100; i++) {
place[i]=0;
prop[i]=0;
rlink[i]=0;
rlink[i+100]=0;
}
for (i=1; i<=locsiz; i++) {
abb[i]=0;
if (ltext[i] != 0 && key[i] != 0) {
k=key[i];
if (longabs(travel[k]) % 1000 == 1)
cond[i]=2;
}
atloc[i]=0;
}
/*
Set up the atloc and rlink arrays as described above.
We'll use the drop subroutine, which prefaces new objects
on the lists. Since we want things in the other order,
we'll run the loop backwards. If the object is in two
locs, we drop it twice. This also sets up "place" and
"fixed" as copies of "plac" and "fixd". Also, since
two-placed objects are typically best described last,
we'll drop them first.
*/
for (i=1; i<=100; i++) {
k=101-i;
if (fixd[k] > 0) {
drop (k+100,fixd[k]);
drop (k,plac[k]);
}
}
for (i=1; i<=100; i++) {
k=101-i;
fixed[k]=fixd[k];
if (plac[k] != 0 && fixd[k] <= 0) drop(k,plac[k]);
}
/*
Treasures, as noted earlier, are objects 50 through
maxtrs (currently 79). Their props are initially -1, and
are set to 0 the first time they are described. Tally
keeps track of how many are not yet found, so we know
when to close the cave. Tally2 counts how many can never
be found (e.g. if lost bird or bridge).
*/
maxtrs=79;
tally=0;
tally2=0;
for (i=50; i<=maxtrs; i++) {
if (ptext[i] != 0) prop[i]= -1;
tally -= prop[i];
}
/*
Clear the hint stuff. hintlc[i] is how long he's been at
loc with cond bit i. hinted(i) is true iff hint i has
been used.
*/
for (i = 1; i<=hntmax; i++)
hinted[i] = hintlc[i] = 0;
/* Define some handy mnemonics. these correspond to object numbers. */
keys=vocab("keys",1);
lamp=vocab("lamp",1);
grate=vocab("grate",1);
cage=vocab("cage",1);
rod=vocab("rod",1);
rod2=rod+1;
steps=vocab("steps",1);
bird=vocab("bird",1);
door=vocab("door",1);
pillow=vocab("pillo",1);
snake=vocab("snake",1);
fissur=vocab("fissu",1);
tablet=vocab("table",1);
clam=vocab("clam",1);
oyster=vocab("oyste",1);
magzin=vocab("magaz",1);
dwarf=vocab("dwarf",1);
knife=vocab("knife",1);
food=vocab("food",1);
bottle=vocab("bottl",1);
water=vocab("water",1);
oil=vocab("oil",1);
plant=vocab("plant",1);
plant2=plant+1;
axe=vocab("axe",1);
mirror=vocab("mirro",1);
dragon=vocab("drago",1);
chasm=vocab("chasm",1);
troll=vocab("troll",1);
troll2=troll+1;
bear=vocab("bear",1);
messag=vocab("messa",1);
vend=vocab("vendi",1);
batter=vocab("batte",1);
/* Objects from 50 through whatever are treasures. here are a few. */
nugget=vocab("gold",1);
coins=vocab("coins",1);
chest=vocab("chest",1);
eggs=vocab("eggs",1);
tridnt=vocab("tride",1);
vase=vocab("vase",1);
emrald=vocab("emera",1);
pyram=vocab("pyram",1);
pearl=vocab("pearl",1);
rug=vocab("rug",1);
chain=vocab("chain",1);
/* These are motion-verb numbers. */
back=vocab("back",0);
look=vocab("look",0);
cave=vocab("cave",0);
nullx=vocab("null",0);
entrnc=vocab("entra",0);
dprssn=vocab("depre",0);
/* And some action verbs. */
say=vocab("say",2);
lock=vocab("lock",2);
throw=vocab("throw",2);
find=vocab("find",2);
invent=vocab("inven",2);
/*
Initialize the dwarves. dloc is loc of dwarves,
hard-wired in. odloc is prior loc of each dwarf,
initially garbage. daltlc is alternate initial loc for
dwarf, in case one of them starts out on top of the
adventurer. (no 2 of the 5 initial locs are adjacent.)
dseen is true if dwarf has seen him. dflag controls the
level of activation of all this:
0 no dwarf stuff yet (wait until reaches hall
of mists)
1 reached hall of mists, but hasn't met first dwarf
2 met first dwarf, others start moving, no
knives thrown yet
3 a knife has been thrown (first set always
misses)
3+ dwarves are mad (increases their accuracy)
Sixth dwarf is special (the pirate). He always starts at
his chest's eventual location inside the maze. This loc
is saved in chloc for ref. The dead end in the other
maze has its loc stored in chloc2.
*/
chloc=114;
chloc2=140;
for (i=1; i<=6; i++)
dseen[i] = 0;
dflag=0;
dloc[1]=19;
dloc[2]=27;
dloc[3]=33;
dloc[4]=44;
dloc[5]=64;
dloc[6]=chloc;
daltlc=18;
/*
Other random flags and counters, as follows:
turns tallies how many commands he's given
(ignores yes/no)
limit lifetime of lamp (not set here)
iwest how many times he's said "west" instead of
"w"
knfloc 0 if no knife here, loc if knife here, -1
after caveat
detail how often we've said "not allowed to give
more detail"
abbnum how often we should print non-abbreviated
descriptions
maxdie number of reincarnation messages available
(up to 5)
numdie number of times killed so far
holdng number of objects being carried
dkill number of dwarves killed (unused in scoring,
needed for msg)
foobar current progress in saying "fee fie foe
foo".
bonus used to determine amount of bonus if he
reaches closing
clock1 number of turns from finding last treasure
till closing
clock2 number of turns from first warning till
blinding flash
logicals were explained earlier
*/
turns=0;
lmwarn=0;
iwest=0;
knfloc=0;
detail=0;
abbnum=5;
for (i=0; i<=4; i++)
if (rtext[2*i+81] != 0) maxdie=i+1;
numdie=0;
/*holdng=0; */
dkill=0;
foobar=0;
bonus=0;
clock1=30;
clock2=50;
closng=0;
panic=0;
closed=0;
gaveup=0;
scorng=0;
/* Report on amount of arrays actually used,
to permit reductions. */
for (kk = locsiz; kk > 0; kk--) {
if (ltext[kk] != 0)
break;
}
obj=0;
for (k = 1; k <= 100; k++) {
if (ptext[k] != 0) obj++;
}
for (k = 1; k <= tabndx; k++) {
if (ktab[k]/1000 == 2) verb=ktab[k]-2000;
}
for (j = rtxsiz; j > 0; j--) {
if (rtext[j] != 0)
break;
}
k=100;
#ifdef INITBUG
printf ("%d of %d messages; ", linuse, linsiz);
printf ("%d of %d travel options;\n", trvs, trvsiz);
printf ("%d of %d vocabulary words; ", tabndx, tabsiz);
printf ("%d of %d locations;\n", kk, locsiz);
printf ("%d of %d objects; ", obj, k);
printf ("%d of %d action verbs;\n", verb, vrbsiz);
printf ("%d of %d rtext messages; ", j, rtxsiz);
printf ("%d of %d class messages;\n", clsses, clssiz);
printf ("%d of %d hints.\n", hntmax, hntsiz);
#endif INITBUG
/* Finally, since we're clearly setting things up for the first time */
printf ("Done!\n");
tvec = time((long *) 0);
srand ((int) (tvec % 32768L));
if ((suspfd = fopen (suspfile, SUSPREAD)) != NULL) {
/* check if we suspended in this release */
srel = getw (suspfd);
slev = getw (suspfd);
if (srel != 1 || slev != 20) {
printf("I deleted a suspend file from version %d.%d\n",
srel, slev);
unlink (suspfile);
hinted[3] = yes (65, 1, 0);
loc = newloc = 1;
limit = hinted[3]? 1000: 330;
}
else
{
/* When did we suspend? */
xtime = getl (suspfd);
#ifndef NOTIME
tvec = time((long *) 0);
if (tvec - xtime < 1800) {
printf ("You cannot restart a suspended game");
printf ("for at least half an hour.\n");
exit (1);
}
#endif
/* Delete the suspend file */
if (unlink (suspfile) == -1)
fatal ("can't unlink suspend file");
fread (&suspbeg, sizeof suspbeg, &suspend - &suspbeg, suspfd);
fclose (suspfd);
printf ("Restarting a suspended game...\n");
newloc = loc;
}
}
else
{
hinted[3]=yes(65,1,0);
loc=newloc=1;
limit = hinted[3]? 1000: 330;
}
/* Can't leave cave once it's closing (except by main office). */
l2:
if (newloc < 9 && newloc != 0 && closng) {
rspeak(130);
newloc=loc;
if (!panic) clock2=15;
panic=1;
}
/*
See if a dwarf has seen him and has come from where he
wants to go. If so, the dwarf's blocking his way. If
coming from place forbidden to pirate (dwarves rooted in
place) let him get out (and attacked).
*/
if (newloc != loc && !forced(loc) && !bitset(loc,3)) {
for (i = 1; i <= 5; i++) {
if (!(odloc[i] != newloc || !dseen[i])) {
newloc=loc;
rspeak(2);
break;
}
}
}
loc=newloc;
/*
Dwarf stuff. See earlier comments for description of
variables. Remember sixth dwarf is pirate and is thus
very different except for motion rules.
First off, don't let the dwarves follow him into a pit or
a wall. Activate the whole mess the first time he gets
as far as the hall of mists (loc 15). If newloc is
forbidden to pirate (in particular, if it's beyond the
troll bridge), bypass dwarf stuff. That way pirate can't
steal return toll, and dwarves can't meet the bear. Also
means dwarves won't follow him into dead end in maze, but
c'est la vie. They'll wait for him outside the dead end.
*/
if (loc == 0 || forced(loc) || bitset((int)newloc,3)) goto l2000;
if (dflag == 0) {
if (loc >= 15) dflag=1;
goto l2000;
}
/*
When we encounter the first dwarf, we kill 0, 1, or 2 of
the 5 dwarves. If any of the survivors is at loc,
replace him with the alternate.
*/
if (dflag == 1) {
if (loc < 15 || pct(95)) goto l2000;
dflag=2;
for (i = 1; i <= 2; i++) {
j=1+ran(5);
if (pct(50)) dloc[j]=0;
}
for (i = 1; i <= 5; i++) {
if (dloc[i] == loc) dloc[i]=daltlc;
odloc[i]=dloc[i];
}
rspeak(3);
drop(axe,loc);
goto l2000;
}
/*
Things are in full swing. Move each dwarf at random,
except if he's seen us he sticks with us. Dwarves never
go to locs <15. If wandering at random, they don't back
up unless there's no alternative. If they don't have to
move, they attack. And, of course, dead dwarves don't do
much of anything.
*/
dtotal=0;
attack=0;
stick=0;
for (i = 1; i <= 6; i++) {
if (dloc[i] == 0) goto l6030;
j=1;
kk=dloc[i];
kk=key[kk];
if (kk != 0) {
do
{
newloc=longabs(travel[kk])/1000 % 1000;
if (newloc <= 300 && newloc >=15 && newloc != odloc[i]
&& !(j > 1 && newloc == tk[j-1]) && j < 20
&& newloc != dloc[i] && !forced((int)newloc)
&& !(i == 6 && bitset((int)newloc,3))
&& longabs(travel[kk] / 1000000) != 100) {
tk[j]=newloc;
j++;
}
kk++;
}
while (travel[kk-1] >= 0);
}
tk[j]=odloc[i];
if (j >= 2) j--;
j=1+ran(j);
odloc[i]=dloc[i];
dloc[i]=tk[j];
dseen[i]=(dseen[i] && loc >= 15)
|| (dloc[i] == loc || odloc[i] == loc);
if (!dseen[i]) goto l6030;
dloc[i]=loc;
if (i != 6) goto l6027;
/*
The pirate's spotted him. He leaves him alone once we've
found chest. k counts if a treasure is here. If not,
and tally=tally2 plus one for an unseen chest, let the
pirate be spotted.
*/
if (loc == chloc || prop[chest] >= 0) goto l6030;
k=0;
for (j = 50; j <= maxtrs; j++) {
/* Pirate won't take pyramid from plover room or dark room (too easy!). */
if (j != pyram || !(loc == plac[pyram]
|| loc == plac[emrald])) {
if (toting(j)) goto l6022;
}
if (here(j)) k=1;
}
if (tally == tally2+1 && k == 0 && place[chest] == 0
&& here(lamp) && prop[lamp] == 1) goto l6025;
if (odloc[6] != dloc[6] && pct(20)) rspeak(127);
goto l6030;
l6022:
rspeak(128);
/* Don't steal chest back from troll! */
if (place[messag] == 0) move(chest,chloc);
move(messag,chloc2);
for (j = 50; j <= maxtrs; j++) {
if (j == pyram && (loc == plac[pyram]
|| loc == plac[emrald])) goto l6023;
if (at(j) && fixed[j] == 0) carry(j,loc);
if (toting(j)) drop(j,chloc);
l6023:
;
}
l6024:
dloc[6]=chloc;
odloc[6]=chloc;
dseen[6]=0;
goto l6030;
l6025:
rspeak(186);
move(chest,chloc);
move(messag,chloc2);
goto l6024;
/* This threatening little dwarf is in the room with him! */
l6027:
dtotal++;
if (odloc[i] != dloc[i]) goto l6030;
attack++;
if (knfloc >= 0) knfloc=loc;
if (ran(1000) < 95*(dflag-2))stick++;
l6030:
;
}
/* Now we know what's happening. let's tell the poor sucker about it. */
if (dtotal == 0) goto l2000;
if (dtotal != 1) {
printf ("There are %d threatening little dwarves", dtotal);
printf (" in the room with you.\n");
} else
rspeak(4);
if (attack == 0) goto l2000;
if (dflag == 2) dflag=3;
/*
Dwarves get VERY mad!
*/
if (attack == 1) {
rspeak(5);
k=52;
}
else {
printf ("%d of them throw knives at you!\n", attack);
k=6;
}
if (stick <= 1) {
rspeak(k+stick);
if (stick == 0) goto l2000;
}
else
printf ("%d of them get you!\n", stick);
oldlc2=loc;
goto l99;
/* Describe the current location and (maybe) get next command. */
/* Print text for current loc. */
l2000:
if (loc == 0) goto l99;
kk=stext[loc];
if (abb[loc] % abbnum == 0 || kk == 0) kk=ltext[loc];
if (forced(loc) || ! dark()) goto l2001;
if (wzdark && pct(35)) goto l90;
kk=rtext[16];
l2001:
if (toting(bear)) rspeak(141);
speak(kk);
k=1;
if (forced(loc)) goto l8;
if (loc == 33 && pct(25) && ! closng) rspeak(8);
/*
Print out descriptions of objects at this location. If
not closing and property value is negative, tally off
another treasure. Rug is special case; once seen, its
prop is 1 (dragon on it) till dragon is killed.
Similarly for chain; prop is initially 1 (locked to
bear). These hacks are because prop=0 is needed to get
full score.
*/
if (dark()) goto l2012;
abb[loc]++;
i=atloc[loc];
for(;;) {
if (i == 0) goto l2012;
obj=i;
if (obj > 100) obj -= 100;
if (obj == steps && toting(nugget)) goto l2008;
if (prop[obj] < 0) {
if (closed) goto l2008;
prop[obj]=0;
if (obj == rug || obj == chain) prop[obj]=1;
tally--;
/* If remaining treasures too elusive, zap his lamp. */
if (tally == tally2 && tally != 0)
limit = limit > 35? 35: limit;
}
kk=prop[obj];
if (obj == steps && loc == fixed[steps]) kk=1;
pspeak(obj,kk);
l2008:
i=rlink[i];
}
l2009:
k=54;
l2010:
spk=k;
l2011:
rspeak(spk);
l2012:
verb=0;
obj=0;
/*
Check if this loc is eligible for any hints. If been
here long enough, branch to help section (on later page).
Hints all come back here eventually to finish the loop.
Ignore "hints" < 4 (special stuff, see database notes).
*/
l2600:
for (hint = 4; hint <= hntmax; hint++) {
if (! (hinted[hint])) {
if (!bitset(loc,hint)) hintlc[hint]= -1;
hintlc[hint]++;
if (hintlc[hint] >= hints[hint][1]) goto l40000;
}
}
/*
Kick the random number generator just to add variety to
the chase. Also, if closing time, check for any objects
being toted with prop < 0 and set the prop to -1-prop.
This way objects won't be described until they've been
picked up and put down separate from their respective
piles. Don't tick clock1 unless well into cave (and not
at Y2).
*/
l2602:
if (!closed) goto l2605;
if (prop[oyster] < 0 && toting(oyster)
) pspeak(oyster,1);
for (i = 1; i <= 100; i++) {
if (toting(i) && prop[i] < 0) prop[i]= -1-prop[i];
}
l2605:
wzdark=dark();
if (knfloc > 0 && knfloc != loc) knfloc=0;
i=ran(1);
getin(wd1,wd1x,wd2,wd2x);
/*
Every input, check "foobar" flag. If zero, nothing's
going on. If pos, make neg. If neg, he skipped a word,
so make it zero.
*/
l2608:
foobar = foobar < 0? 0: -foobar;
turns++;
if (verb == say && !blankp(wd2)) verb=0;
if (verb == say) goto l4090;
if (tally == 0 && loc >= 15 && loc != 33) clock1--;
if (clock1 == 0) goto l10000;
if (clock1 < 0) clock2--;
if (clock2 == 0) goto l11000;
if (prop[lamp] == 1) limit--;
if (limit <= 30 && here(batter) && prop[batter] == 0
&& here(lamp)) goto l12000;
if (limit == 0) goto l12400;
if (limit < 0 && loc <= 8) goto l12600;
if (limit <= 30) goto l12200;
l19999:
k=43;
if (liqloc(loc) == water) k=70;
if (eqp (wd1, "enter") && (eqp (wd2, "strea") || eqp (wd2, "water")))
goto l2010;
if (eqp (wd1, "enter") && !blankp(wd2)) goto l2800;
if (!eqp (wd1, "water") && !eqp (wd1, "oil")
|| (!eqp (wd2, "plant") && !eqp (wd2, "door "))) goto l2610;
if (at(vocab(wd2,1))) cpy (wd2, "pour ");
l2610:
if (!eqp(wd1, "west ")) goto l2630;
iwest++;
if (iwest == 10) rspeak(17);
l2630:
i=vocab(wd1,-1);
if (i == -1) goto l3000;
k=i % 1000;
kq=i/1000+1;
switch (kq - 1) {
case 0:
goto l8;
case 1:
goto l5000;
case 2:
goto l4000;
case 3:
goto l2010;
}
bug(22);
/* Get second word for analysis. */
l2800:
cpy (wd1, wd2);
cpy (wd1x, wd2x);
cpy (wd2, " ");
goto l2610;
/* Gee, I don't understand. */
l3000:
spk=60;
if (pct(20)) spk=61;
if (pct(20)) spk=13;
rspeak(spk);
goto l2600;
/*
Analyse a verb. remember what it was, go back for object
if second word unless verb is "say", which snarfs
arbitrary second word.
*/
l4000:
verb=k;
spk=actspk[verb];
if (!blankp(wd2) && verb != say) goto l2800;
if (verb == say)
if (blankp (wd2)) goto l4080;
else goto l4090;
if (obj != 0) goto l4090;
/* Analyse an intransitive verb (ie, no object given yet). */
l4080:
switch (verb) {
case 1:
goto l8010; /* take */
case 2:
goto l8000; /* drop */
case 3:
goto l8000; /* say */
case 4:
goto l8040; /* open */
case 5:
goto l2009; /* noth */
case 6:
goto l8040; /* lock */
case 7:
goto l9070; /* on */
case 8:
goto l9080; /* off */
case 9:
goto l8000; /* wave */
case 10:
goto l8000; /* calm */
case 11:
goto l2011; /* walk */
case 12:
goto l9120; /* kill */
case 13:
goto l9130; /* pour */
case 14:
goto l8140; /* eat */
case 15:
goto l9150; /* drnk */
case 16:
goto l8000; /* rub */
case 17:
goto l8000; /* toss */
case 18:
goto l8180; /* quit */
case 19:
goto l8000; /* find */
case 20:
goto l8200; /* invn */
case 21:
goto l8000; /* feed */
case 22:
goto l9220; /* fill */
case 23:
goto l9230; /* blst */
case 24:
goto l8240; /* scor */
case 25:
goto l8250; /* foo */
case 26:
goto l8260; /* brf */
case 27:
goto l8270; /* read */
case 28:
goto l8000; /* brek */
case 29:
goto l8000; /* wake */
case 30:
goto l8300; /* susp */
case 31:
goto l8310; /* hour */
case 32:
goto setlog; /* log */
}
bug(23);
/* Analyse a transitive verb. */
l4090:
switch (verb) {
case 1:
goto l9010; /* take */
case 2:
goto l9020; /* drop */
case 3:
goto l9030; /* say */
case 4:
goto l9040; /* open */
case 5:
goto l2009; /* noth */
case 6:
goto l9040; /* lock */
case 7:
goto l9070; /* on */
case 8:
goto l9080; /* off */
case 9:
goto l9090; /* wave */
case 10:
goto l2011; /* calm */
case 11:
goto l2011; /* walk */
case 12:
goto l9120; /* kill */
case 13:
goto l9130; /* pour */
case 14:
goto l9140; /* eat */
case 15:
goto l9150; /* drnk */
case 16:
goto l9160; /* rub */
case 17:
goto l9170; /* toss */
case 18:
goto l2011; /* quit */
case 19:
goto l9190; /* find */
case 20:
goto l9190; /* invn */
case 21:
goto l9210; /* feed */
case 22:
goto l9220; /* fill */
case 23:
goto l9230; /* blst */
case 24:
goto l2011; /* scor */
case 25:
goto l2011; /* foo */
case 26:
goto l2011; /* brf */
case 27:
goto l9270; /* read */
case 28:
goto l9280; /* brek */
case 29:
goto l9290; /* wake */
case 30:
goto l2011; /* susp */
case 31:
goto l2011; /* hour */
case 32:
goto l2011; /* log */
}
bug(24);
/*
Analyze an object word. See if the thing is here,
whether we've got a verb yet, and so on. Object must be
here unless verb is "find" or "invent(ory)" (and no new
verb yet to be analyzed). Water and oil are also funny,
since they are never actually dropped at any location,
but might be here inside the bottle or as a feature of
the location.
*/
l5000:
obj=k;
if (fixed[k] != loc && ! here(k)) goto l5100;
l5010:
if (!blankp(wd2)) goto l2800;
if (verb != 0) goto l4090;
a5toa1(wd1,wd1x,tkword);
printf ("What do you want to do with the %s?\n", tkword);
goto l2600;
l5100:
if (k != grate) goto l5110;
if (loc == 1 || loc == 4 || loc == 7) k=dprssn;
if (loc > 9 && loc < 15) k=entrnc;
if (k != grate) goto l8;
l5110:
if (k != dwarf) goto l5120;
for (i = 1; i <= 5; i++) {
if (dloc[i] == loc && dflag >= 2) goto l5010;
}
l5120:
if ((liq() == k && here(bottle))
|| k == liqloc(loc)) goto l5010;
if (obj != plant || ! at(plant2) || prop[plant2] == 0
) goto l5130;
obj=plant2;
goto l5010;
l5130:
if (obj == knife && knfloc == loc) {
knfloc= -1;
spk=116;
goto l2011;
}
if (obj != rod || !here(rod2)) goto l5190;
obj=rod2;
goto l5010;
l5190:
if ((verb == find || verb == invent) && blankp (wd2)
) goto l5010;
a5toa1(wd1,wd1x,tkword);
printf ("I see no %s here!\n", tkword);
goto l2012;
/*
Figure out the new location
Given the current location in "loc", and a motion verb
number in "k", put the new location in "newloc". The
current loc is saved in "oldloc" in case he wants to
retreat. The current oldloc is saved in oldlc2, in case
he dies. (if he does, newloc will be limbo, and oldloc
will be what killed him, so we need oldlc2, which is the
last place he was safe.)
*/
l8:
kk=key[loc];
newloc=loc;
if (kk == 0) bug(26);
if (k == nullx) goto l2;
if (k == back) goto l20;
if (k == look) goto l30;
if (k == cave) goto l40;
oldlc2=oldloc;
oldloc=loc;
l9:
ll=longabs(travel[kk]);
if (ll % 1000 == 1 || ll % 1000 == k) goto l10;
if (travel[kk] < 0) goto l50;
kk++;
goto l9;
l10:
ll/=1000;
l11:
newloc=ll/1000;
k=newloc % 100;
if (newloc <= 300) goto l13;
if (prop[k] != newloc/100-3) goto l16;
l12:
if (travel[kk] < 0) bug(25);
kk++;
newloc=longabs(travel[kk])/1000;
if (newloc == ll) goto l12;
ll=newloc;
goto l11;
l13:
if (newloc <= 100) goto l14;
if (toting(k) || (newloc > 200 && at(k))) goto l16;
goto l12;
l14:
if (newloc != 0 && !pct((int)newloc)) goto l12;
l16:
newloc=ll % 1000;
if (newloc <= 300) goto l2;
if (newloc <= 500) goto l30000;
rspeak((int)newloc-500);
newloc=loc;
goto l2;
/*
Special motions come here. Labelling convention:
statement numbers nnnxx (xx=00-99) are used for special
case number nnn (nnn=301-500).
*/
l30000:
newloc=newloc-300;
switch ((int) newloc-1) {
case 0:
goto l30100;
case 1:
goto l30200;
case 2:
goto l30300;
}
bug(20);
/*
Travel 301. Plover-alcove passage. can carry only
emerald. Note: travel table must include "useless"
entries going through passage, which can never be used
for actual motion, but can be spotted by "go back".
*/
l30100:
newloc=99+100-loc;
if (holdng == 0 || (holdng == 1 && toting(emrald))) goto l2;
newloc=loc;
rspeak(117);
goto l2;
/*
Travel 302. Plover transport. Drop the emerald (only
use special travel if toting it), so he's forced to use
the plover-passage to get it out. Having dropped it, go
back and pretend he wasn't carrying it after all.
*/
l30200:
drop(emrald,loc);
goto l12;
/*
Travel 303. Troll bridge. Must be done only as special
motion so that dwarves won't wander across and encounter
the bear. (They won't follow the player there because
that region is forbidden to the pirate.) If
prop(troll)=1, he's crossed since paying, so step out and
block him. (Standard travel entries check for
prop(troll)=0.) Special stuff for bear.
*/
l30300:
if (prop[troll] != 1) goto l30310;
pspeak(troll,1);
prop[troll]=0;
move(troll2,0);
move(troll2+100,0);
move(troll,plac[troll]);
move(troll+100,fixd[troll]);
juggle(chasm);
newloc=loc;
goto l2;
l30310:
newloc=plac[troll]+fixd[troll]-loc;
if (prop[troll] == 0) prop[troll]=1;
if (!toting(bear)) goto l2;
rspeak(162);
prop[chasm]=1;
prop[troll]=2;
drop(bear,(int)newloc);
fixed[bear]= -1;
prop[bear]=3;
if (prop[spices] < 0)tally2++;
oldlc2=newloc;
goto l99;
/* End of specials. */
/*
Handle "go back". Look for verb which goes from loc to
oldloc, or to oldlc2 if oldloc has forced-motion. k2
saves entry -> forced loc -> previous loc.
*/
l20:
k=oldloc;
if (forced(k)) k=oldlc2;
oldlc2=oldloc;
oldloc=loc;
k2=0;
if (k != loc) goto l21;
rspeak(91);
goto l2;
l21:
ll=(longabs(travel[kk])/1000) % 1000;
if (ll == k) goto l25;
if (ll > 300) goto l22;
j=key[ll];
if (forced((int)ll) && (longabs(travel[j])/1000) % 1000 == k
) k2=kk;
l22:
if (travel[kk] < 0) goto l23;
kk++;
goto l21;
l23:
kk=k2;
if (kk != 0) goto l25;
rspeak(140);
goto l2;
l25:
k=longabs(travel[kk]) % 1000;
kk=key[loc];
goto l9;
/*
Look. Can't give more detail. Pretend it wasn't dark
(though it may "now" be dark) so he won't fall into a pit
while staring into the gloom.
*/
l30:
if (detail < 3) rspeak(15);
detail++;
wzdark=0;
abb[loc]=0;
goto l2;
/* Cave. Different messages depending on whether above ground. */
l40:
if (loc < 8) rspeak(57);
if (loc >= 8) rspeak(58);
goto l2;
/* Non-applicable motion. Various messages depending on word given. */
l50:
spk=12;
if (k >= 43 && k <= 50) spk=9;
if (k == 29 || k == 30) spk=9;
if (k == 7 || k == 36 || k == 37) spk=10;
if (k == 11 || k == 19) spk=11;
if (verb == find || verb == invent) spk=59;
if (k == 62 || k == 65) spk=42;
if (k == 17) spk=80;
rspeak(spk);
goto l2;
/*
"You're dead, Jim."
If the current loc is zero, it means the clown got
himself killed. We'll allow this maxdie times. maxdie
is automatically set based on the number of snide
messages available. Each death results in a message (81,
83, etc.) which offers reincarnation; if accepted, this
results in message 82, 84, etc. The last time, if he
wants another chance, he gets a snide remark as we exit.
When reincarnated, all objects being carried get dropped
at oldlc2 (presumably the last place prior to being
killed) without change of props. The loop runs backwards
to assure that the bird is dropped before the cage.
(This kluge could be changed once we're sure all
references to bird and cage are done by keywords.) The
lamp is a special case (it wouldn't do to leave it in the
cave). It is turned off and left outside the building
(only if he was carrying it, of course). He himself is
left inside the building (and heaven help him if he tries
to xyzzy back into the cave without the lamp!). oldloc
is zapped so he can't just "retreat".
The easiest way to get killed is to fall into a pit in
pitch darkness.
*/
l90:
rspeak(23);
oldlc2=loc;
/* Okay, he's dead. Let's get on with it. */
l99:
if (closng) goto l95;
yea=yes(81+numdie*2,82+numdie*2,54);
numdie++;
if (numdie == maxdie || !yea) goto l20000;
place[water]=0;
place[oil]=0;
if (toting(lamp)) prop[lamp]=0;
for (j = 1; j <= 100; j++) {
i=101-j;
if (!toting(i)) goto l98;
k=oldlc2;
if (i == lamp) k=1;
drop(i,k);
l98:
;
}
loc=3;
oldloc=loc;
goto l2000;
/* He died during closing time. No resurrection. tally up
a death and exit. */
l95:
rspeak(131);
numdie++;
goto l20000;
/*
Routines for performing the various action verbs
Statement numbers in this section are 8000 for
intransitive verbs, 9000 for transitive, plus ten times
the verb number. Many intransitive verbs use the
transitive code, and some verbs use code for other verbs,
as noted below.
Random intransitive verbs come here. Clear obj just in
case (see "attack").
*/
l8000:
a5toa1(wd1,wd1x,tkword);
printf ("%s what?\n", tkword);
obj=0;
goto l2600;
/* Carry, no object given yet. OK if only one object present. */
l8010:
if (atloc[loc] == 0 || rlink[atloc[loc]] != 0) goto l8000;
for (i = 1; i <= 5; i++) {
if (dloc[i] == loc && dflag >= 2) goto l8000;
}
obj=atloc[loc];
/*
Carry an object. Special cases for bird and cage (if
bird in cage, can't take one without the other. Liquids
also special, since they depend on status of bottle.
Also various side effects, etc.
*/
l9010:
if (toting(obj)) goto l2011;
spk=25;
if (obj == plant && prop[plant] <= 0) spk=115;
if (obj == bear && prop[bear] == 1) spk=169;
if (obj == chain && prop[bear] != 0) spk=170;
if (fixed[obj] != 0) goto l2011;
if (obj != water && obj != oil) goto l9017;
if (here(bottle) && liq() == obj) goto l9018;
obj=bottle;
if (toting(bottle) && prop[bottle] == 1) goto l9220;
if (prop[bottle] != 1) spk=105;
if (!toting(bottle)) spk=104;
goto l2011;
l9018:
obj=bottle;
l9017:
if (holdng < 7) goto l9016;
rspeak(92);
goto l2012;
l9016:
if (obj != bird) goto l9014;
if (prop[bird] != 0) goto l9014;
if (!toting(rod)) goto l9013;
rspeak(26);
goto l2012;
l9013:
if (toting(cage)) goto l9015;
rspeak(27);
goto l2012;
l9015:
prop[bird]=1;
l9014:
if ((obj == bird || obj == cage) && prop[bird] != 0
) carry(bird+cage-obj,loc);
carry(obj,loc);
k=liq();
if (obj == bottle && k != 0) place[k]= -1;
goto l2009;
/*
Discard object. "Throw" also comes here for most
objects. Special cases for bird (might attack snake or
dragon) and cage (might contain bird) and vase. Drop
coins at vending machine for extra batteries.
*/
l9020:
if (toting(rod2) && obj == rod && ! toting(rod)) obj=rod2;
if (!toting(obj)) goto l2011;
if (obj != bird || ! here(snake)) goto l9024;
rspeak(30);
if (closed) goto l19000;
dstroy(snake);
/* Set prop for use by travel options */
prop[snake]=1;
l9021:
k=liq();
if (k == obj) obj=bottle;
if (obj == bottle && k != 0) place[k]=0;
if (obj == cage && prop[bird] != 0) drop(bird,loc);
if (obj == bird) prop[bird]=0;
drop(obj,loc);
goto l2012;
l9024:
if (obj != coins || ! here(vend)) goto l9025;
dstroy(coins);
drop(batter,loc);
pspeak(batter,0);
goto l2012;
l9025:
if (obj != bird || ! at(dragon) || prop[dragon] != 0
) goto l9026;
rspeak(154);
dstroy(bird);
prop[bird]=0;
if (place[snake] == plac[snake])tally2++;
goto l2012;
l9026:
if (obj != bear || !at(troll)) goto l9027;
rspeak(163);
move(troll,0);
move(troll+100,0);
move(troll2,plac[troll]);
move(troll2+100,fixd[troll]);
juggle(chasm);
prop[troll]=2;
goto l9021;
l9027:
if (obj == vase && loc != plac[pillow]) goto l9028;
rspeak(54);
goto l9021;
l9028:
prop[vase]=2;
if (at(pillow)) prop[vase]=0;
pspeak(vase,prop[vase]+1);
if (prop[vase] != 0) fixed[vase]= -1;
goto l9021;
/* Say. Echo wd2 (or wd1 if no wd2 (say what?, etc.).)
Magic words override. */
l9030:
a5toa1(wd2,wd2x,tkword);
if (blankp(wd2)) a5toa1(wd1,wd1x,tkword);
else cpy(wd1,wd2);
i=vocab(wd1,-1);
if (i == 62 || i == 65 || i == 71 || i == 2025) goto l9035;
printf ("Okay, \"%s\"\n", tkword);
goto l2012;
l9035:
cpy(wd2, " ");
obj=0;
goto l2630;
/* Lock, unlock, no object given. Assume various things if present. */
l8040:
spk=28;
if (here(clam)) obj=clam;
if (here(oyster)) obj=oyster;
if (at(door)) obj=door;
if (at(grate)) obj=grate;
if (obj != 0 && here(chain)) goto l8000;
if (here(chain)) obj=chain;
if (obj == 0) goto l2011;
/* Lock, unlock object. Special stuff for opening
clam/oyster and for chain. */
l9040:
if (obj == clam || obj == oyster) goto l9046;
if (obj == door) spk=111;
if (obj == door && prop[door] == 1) spk=54;
if (obj == cage) spk=32;
if (obj == keys) spk=55;
if (obj == grate || obj == chain) spk=31;
if (spk != 31 || ! here(keys)) goto l2011;
if (obj == chain) goto l9048;
if (!closng) goto l9043;
k=130;
if (!panic) clock2=15;
panic=1;
goto l2010;
l9043:
k=34+prop[grate];
prop[grate]=1;
if (verb == lock) prop[grate]=0;
k=k+2*prop[grate];
goto l2010;
/* Clam/oyster. */
l9046:
k=0;
if (obj == oyster) k=1;
spk=124+k;
if (toting(obj)) spk=120+k;
if (!toting(tridnt)) spk=122+k;
if (verb == lock) spk=61;
if (spk != 124) goto l2011;
dstroy(clam);
drop(oyster,loc);
drop(pearl,105);
goto l2011;
/* Chain. */
l9048:
if (verb == lock) goto l9049;
spk=171;
if (prop[bear] == 0) spk=41;
if (prop[chain] == 0) spk=37;
if (spk != 171) goto l2011;
prop[chain]=0;
fixed[chain]=0;
if (prop[bear] != 3) prop[bear]=2;
fixed[bear]=2-prop[bear];
goto l2011;
l9049:
spk=172;
if (prop[chain] != 0) spk=34;
if (loc != plac[chain]) spk=173;
if (spk != 172) goto l2011;
prop[chain]=2;
if (toting(chain)) drop(chain,loc);
fixed[chain]= -1;
goto l2011;
/* Light lamp */
l9070:
if(!here(lamp)) goto l2011;
spk=184;
if(limit < 0) goto l2011;
prop[lamp]=1;
rspeak(39);
if(wzdark) goto l2000;
goto l2012;
/* Lamp off */
l9080:
if(!here(lamp)) goto l2011;
prop[lamp]=0;
rspeak(40);
if(dark()) rspeak(16);
goto l2012;
/* Wave. No effect unless waving rod at fissure. */
l9090:
if ((!toting(obj)) && (obj != rod || ! toting(rod2))
) spk=29;
if (obj != rod || ! at(fissur) || ! toting(obj)
|| closng) goto l2011;
prop[fissur]=1-prop[fissur];
pspeak(fissur,2-prop[fissur]);
goto l2012;
/*
Attack. Assume target if unambiguous. "throw" also
links here. Attackable objects fall into two categories:
enemies (snake, dwarf, etc.) and others (bird, clam).
Ambiguous if two enemies, or if no enemies but two
others.
*/
l9120:
for (i = 1; i <= 5; i++) {
if(dloc[i] == loc && dflag >= 2) goto l9122;
}
i=0;
l9122:
if(obj != 0) goto l9124;
if(i != 0) obj=dwarf;
if(here(snake)) obj=obj*100+snake;
if(at(dragon) && prop[dragon] == 0) obj=obj*100+dragon;
if(at(troll)) obj=obj*100+troll;
if(here(bear) && prop[bear] == 0) obj=obj*100+bear;
if(obj > 100) goto l8000;
if(obj != 0) goto l9124;
/* Can't attack bird by throwing axe. */
if(here(bird) && verb != throw) obj=bird;
/* Clam and oyster both treated as clam for intransitive
case; no harm done. */
if(here(clam) || here(oyster)) obj=100*obj+clam;
if(obj > 100) goto l8000;
l9124:
if(obj != bird) goto l9125;
spk=137;
if(closed) goto l2011;
dstroy(bird);
prop[bird]=0;
if(place[snake] == plac[snake])tally2++;
spk=45;
l9125:
if(obj == 0) spk=44;
if(obj == clam || obj == oyster) spk=150;
if(obj == snake) spk=46;
if(obj == dwarf) spk=49;
if(obj == dwarf && closed) goto l19000;
if(obj == dragon) spk=167;
if(obj == troll) spk=157;
if(obj == bear) spk=165+(prop[bear]+1)/2;
if(obj != dragon || prop[dragon] != 0) goto l2011;
/*
Fun stuff for dragon. If he insists on attacking it,
win! Set prop to dead, move dragon to central loc (still
fixed), move rug there (not fixed), and move him there,
too. Then do a null motion to get new description.
*/
rspeak(49);
verb=0;
obj=0;
getin(wd1,wd1x,wd2,wd2x);
if (!eqp (wd1, "y") && !eqp (wd1, "yes")) goto l2608;
pspeak(dragon,1);
prop[dragon]=2;
prop[rug]=0;
k=(plac[dragon]+fixd[dragon])/2;
move(dragon+100,-1);
move(rug+100,0);
move(dragon,k);
move(rug,k);
for (obj=1; obj<=100; obj++) {
if (place[obj] == plac[dragon] || place[obj] == fixd[dragon]
) move(obj,k);
}
loc=k;
k=nullx;
goto l8;
/*
Pour. If no object, or object is bottle, assume contents
of bottle. Special tests for pouring water or oil on
plant or rusty door.
*/
l9130:
if(obj == bottle || obj == 0) obj=liq();
if(obj == 0) goto l8000;
if(!toting(obj)) goto l2011;
spk=78;
if(obj != oil && obj != water) goto l2011;
prop[bottle]=1;
place[obj]=0;
spk=77;
if(!(at(plant) || at(door))) goto l2011;
if(at(door)) goto l9132;
spk=112;
if(obj != water) goto l2011;
pspeak(plant,prop[plant]+1);
prop[plant]=(prop[plant]+2) % 6;
prop[plant2]=prop[plant]/2;
k=nullx;
goto l8;
l9132:
prop[door]=0;
if(obj == oil) prop[door]=1;
spk=113+prop[door];
goto l2011;
/*
Eat. Intransitive: assume food if present, else ask
what. Transitive: food ok, some things lose appetite,
rest are ridiculous.
*/
l8140:
if(!here(food)) goto l8000;
l8142:
dstroy(food);
spk=72;
goto l2011;
l9140:
if(obj == food) goto l8142;
if (obj == bird || obj == snake || obj == clam || obj == oyster
|| obj == dwarf || obj == dragon || obj == troll
|| obj == bear) spk=71;
goto l2011;
/*
Drink. If no object, assume water and look for it here.
if water is in the bottle, drink that, else must be at a
water loc, so drink stream.
*/
l9150:
if (obj == 0 && liqloc(loc) != water && (liq() != water
|| ! here(bottle))) goto l8000;
if(obj != 0 && obj != water) spk=110;
if (spk == 110 || liq() != water || ! here(bottle)
) goto l2011;
prop[bottle]=1;
place[water]=0;
spk=74;
goto l2011;
/* Rub. Yields various snide remarks. */
l9160:
if(obj != lamp) spk=76;
goto l2011;
/*
Throw. Same as discard unless axe. Then same as attack
except ignore bird, and if dwarf is present then one
might be killed. (only way to do so!) Axe also special
for dragon, bear, and troll. Treasures special for
troll.
*/
l9170:
if(toting(rod2) && obj == rod && ! toting(rod)) obj=rod2;
if(!toting(obj)) goto l2011;
if(obj >= 50 && obj <= maxtrs && at(troll)) goto l9178;
if(obj == food && here(bear)) goto l9177;
if(obj != axe) goto l9020;
for (i = 1; i <= 5; i++) {
/* Needn't check dflag if axe is here. */
if(dloc[i] == loc) goto l9172;
}
spk=152;
if(at(dragon) && prop[dragon] == 0) goto l9175;
spk=158;
if(at(troll)) goto l9175;
if(here(bear) && prop[bear] == 0) goto l9176;
obj=0;
goto l9120;
l9172:
spk=48;
if(ran(3) == 0) goto l9175;
dseen[i]=0;
dloc[i]=0;
spk=47;
dkill++;
if(dkill == 1) spk=149;
l9175:
rspeak(spk);
drop(axe,loc);
k=nullx;
goto l8;
/* This'll teach him to throw the axe at the bear! */
l9176:
spk=164;
drop(axe,loc);
fixed[axe]= -1;
prop[axe]=1;
juggle(bear);
goto l2011;
/* But throwing food is another story. */
l9177:
obj=bear;
goto l9210;
l9178:
spk=159;
/* Snarf a treasure for the troll. */
drop(obj,0);
move(troll,0);
move(troll+100,0);
drop(troll2,plac[troll]);
drop(troll2+100,fixd[troll]);
juggle(chasm);
goto l2011;
/* Quit. Intransitive only. Verify intent and exit if
that's what he wants. */
l8180:
gaveup=yes(22,54,54);
if(gaveup) goto l20000;
goto l2012;
/* Find. Might be carrying it, or it might be here. Else give caveat. */
l9190:
if (at(obj) || (liq() == obj && at(bottle))
|| k == liqloc(loc)) spk=94;
for (i = 1; i <= 5; i++) {
if(dloc[i] == loc && dflag >= 2 && obj == dwarf) spk=94;
}
if(closed) spk=138;
if(toting(obj)) spk=24;
goto l2011;
/* Inventory. If object, treat same as find. Else report
on current burden. */
l8200:
spk=98;
for (i = 1; i <= 100; i++) {
if(i == bear || ! toting(i)) goto l8201;
if(spk == 98) rspeak(99);
blklin=0;
pspeak(i,-1);
blklin=1;
spk=0;
l8201:
;
}
if(toting(bear)) spk=141;
goto l2011;
/*
Feed. If bird, no seed. snake, dragon, troll: quip. If
dwarf, make him mad. Bear, special.
*/
l9210:
if(obj != bird) goto l9212;
spk=100;
goto l2011;
l9212:
if(obj != snake && obj != dragon && obj != troll) goto l9213;
spk=102;
if(obj == dragon && prop[dragon] != 0) spk=110;
if(obj == troll) spk=182;
if(obj != snake || closed || ! here(bird)) goto l2011;
spk=101;
dstroy(bird);
prop[bird]=0;
tally2++;
goto l2011;
l9213:
if(obj != dwarf) goto l9214;
if(!here(food)) goto l2011;
spk=103;
dflag++;
goto l2011;
l9214:
if(obj != bear) goto l9215;
if(prop[bear] == 0) spk=102;
if(prop[bear] == 3) spk=110;
if(!here(food)) goto l2011;
dstroy(food);
prop[bear]=1;
fixed[axe]=0;
prop[axe]=0;
spk=168;
goto l2011;
l9215:
spk=14;
goto l2011;
/* Fill. Bottle must be empty, and some liquid available.
(vase is nasty.) */
l9220:
if(obj == vase) goto l9222;
if(obj != 0 && obj != bottle) goto l2011;
if(obj == 0 && ! here(bottle)) goto l8000;
spk=107;
if(liqloc(loc) == 0) spk=106;
if(liq() != 0) spk=105;
if(spk != 107) goto l2011;
prop[bottle]=(cond[loc] % 4)/2;
prop[bottle]=prop[bottle]*2;
k=liq();
if(toting(bottle)) place[k]= -1;
if(k == oil) spk=108;
goto l2011;
l9222:
spk=29;
if(liqloc(loc) == 0) spk=144;
if(liqloc(loc) == 0 || !toting(vase)) goto l2011;
rspeak(145);
prop[vase]=2;
fixed[vase]= -1;
goto l9024;
/* Blast. No effect unless you've got dynamite, which is a
neat trick! */
l9230:
if(prop[rod2] < 0 || ! closed) goto l2011;
bonus=133;
if(loc == 115) bonus=134;
if(here(rod2)) bonus=135;
rspeak(bonus);
goto l20000;
/* Score. Go to scoring section, which will return to 8241
if scorng is true. */
l8240:
scorng=1;
goto l20000;
l8241:
scorng=0;
printf ("If you were to quit now, you would score ");
printf ("%d out of a possible %d in %d turns.\n",
score, mxscor, turns+1);
goto l2012;
/*
Fee fie foe foo (and fum). Advance to next state if given
in proper order. Look up wd1 in section 3 of vocab to
determine which word we've got. Last word zips the eggs
back to the giant room (unless already there).
*/
l8250:
k=vocab(wd1,3);
spk=42;
if(foobar == 1-k) goto l8252;
if(foobar != 0) spk=151;
goto l2011;
l8252:
foobar=k;
if(k != 4) goto l2009;
foobar=0;
if (place[eggs] == plac[eggs]
|| (toting(eggs) && loc == plac[eggs])) goto l2011;
/* Bring back troll if we steal the eggs back from him
before crossing. */
if (place[eggs] == 0 && place[troll] == 0 && prop[troll] == 0
) prop[troll]=1;
k=2;
if(here(eggs)) k=1;
if(loc == plac[eggs]) k=0;
move(eggs,plac[eggs]);
pspeak(eggs,k);
goto l2012;
/* Brief. Intransitive only. Suppress long descriptions
after first time. */
l8260:
spk=156;
abbnum=10000;
detail=3;
goto l2011;
/* Read. Magazines in dwarvish, message we've seen, and .
. . oyster? */
l8270:
if(here(magzin)) obj=magzin;
if(here(tablet)) obj=obj*100+tablet;
if(here(messag)) obj=obj*100+messag;
if(closed && toting(oyster)) obj=oyster;
if(obj > 100 || obj == 0 || dark()) goto l8000;
l9270:
if(dark()) goto l5190;
if(obj == magzin) spk=190;
if(obj == tablet) spk=196;
if(obj == messag) spk=191;
if(obj == oyster && hinted[2] && toting(oyster)) spk=194;
if (obj != oyster || hinted[2] || !toting(oyster)
|| !closed) goto l2011;
hinted[2]=yes(192,193,54);
goto l2012;
/* Break. Only works for mirror in repository and, of
course, the vase. */
l9280:
if(obj == mirror) spk=148;
if(obj == vase && prop[vase] == 0) goto l9282;
if(obj != mirror || !closed) goto l2011;
rspeak(197);
goto l19000;
l9282:
spk=198;
if(toting(vase)) drop(vase,loc);
prop[vase]=2;
fixed[vase]= -1;
goto l2011;
/* Wake. Only use is to disturb the dwarves. */
l9290:
if(obj != dwarf || !closed) goto l2011;
rspeak(199);
goto l19000;
/*
Suspend. Exit leaving things restartable.
*/
l8300:
if ((suspfd = fopen (suspfile, SUSPWRITE)) == NULL) {
printf ("Something's wrong...I can't suspend.\n");
if (hungup) {
hungup = 0;
goto l20000;
}
goto l2012;
}
hungup = 0;
printf ("OK...I'm suspending this game in %s\n", suspfile);
/* Block interrupts to ensure completion of suspension */
signal (SIGINT, SIG_IGN);
signal (SIGQUIT, SIG_IGN);
signal (SIGHUP, SIG_IGN);
/* Write the release and level into the suspend file */
putw (1, suspfd);
putw (20, suspfd);
/* Write the time to prevent premature resumption */
tvec = time(0);
putl (tvec, suspfd);
/* Write the suspend data into the file */
fwrite (&suspbeg, sizeof suspbeg, &suspend - &suspbeg, suspfd);
/* Make sure everything went ok */
if (ferror (suspfd))
fatal ("I/O error during suspension");
fclose (suspfd);
#ifdef NOTIME
printf ("Play will resume automatically next time.\n");
#else
printf ("You may resume play half an hour from now.\n");
#endif
exit(0);
/* Hours. Report current non-prime-time hours. */
l8310:
printf (HOURS);
goto l2012;
/* Log. Toggle loggin either on or off */
setlog:
logon = ! logon;
if (logon)
printf ("Log on.\n");
else
printf ("Log off.\n");
goto l2012;
/*
hints
Come here if he's been long enough at required loc(s) for
some unused hint. Hint number is in variable "hint".
branch to quick test for additional conditions, then come
back to do neat stuff. goto 40010 if conditions are met
and we want to offer the hint. goto 40020 to clear
hintlc back to zero, 40030 to take no action yet.
*/
l40000:
switch (hint-4) {
case 0:
goto l40400; /* cave */
case 1:
goto l40500; /* bird */
case 2:
goto l40600; /* snake */
case 3:
goto l40700; /* maze */
case 4:
goto l40800; /* dark */
case 5:
goto l40900; /* witt */
}
bug(27);
l40010:
hintlc[hint]=0;
if(!yes(hints[hint][3],0,54)) goto l2602;
printf ("I am prepared to give you a hint,");
printf (" but it will cost you %d points.\n", hints[hint][2]);
hinted[hint]=yes(175,hints[hint][4],54);
if (hinted[hint] && limit > 30
) limit=limit+30*hints[hint][2];
l40020:
hintlc[hint]=0;
l40030:
goto l2602;
/* Now for the quick tests. See database description for
one-line notes. */
l40400:
if(prop[grate] == 0 && ! here(keys)) goto l40010;
goto l40020;
l40500:
if(here(bird) && toting(rod) && obj == bird) goto l40010;
goto l40030;
l40600:
if(here(snake) && ! here(bird)) goto l40010;
goto l40020;
l40700:
if (atloc[loc] == 0 && atloc[oldloc] == 0
&& atloc[oldlc2] == 0 && holdng > 1) goto l40010;
goto l40020;
l40800:
if(prop[emrald] != -1 && prop[pyram] == -1) goto l40010;
goto l40020;
l40900:
goto l40010;
/*
Cave closing and scoring
These sections handle the closing of the cave. The cave
closes "clock1" turns after the last treasure has been
located (including the pirate's chest, which may of
course never show up). Note that the treasures need not
have been taken yet, just located. Hence clock1 must be
large enough to get out of the cave (it only ticks while
inside the cave). When it hits zero, we branch to 10000
to start closing the cave, and then sit back and wait for
him to try to get out. If he doesn't within clock2
turns, we close the cave; if he does try, we assume he
panics, and give him a few additional turns to get
frantic before we close. When clock2 hits zero, we
branch to 11000 to transport him into the final puzzle.
Note that the puzzle depends upon all sorts of random
things. For instance, there must be no water or oil,
since there are beanstalks which we don't want to be able
to water, since the code can't handle it. Also, we can
have no keys, since there is a grate (having moved the
fixed object!) there separating him from all the
treasures. Most of these problems arise from the use of
negative prop numbers to suppress the object descriptions
until he's actually moved the objects.
When the first warning comes, we lock the grate, destroy
the bridge, kill all the dwarves (and the pirate), remove
the troll and bear (unless dead), and set "closng" to
true. Leave the dragon; too much trouble to move it.
From now until clock2 runs out, he cannot unlock the
grate, move to any location outside the cave (loc<9), or
create the bridge. Nor can he be resurrected if he dies.
Note that the snake is already gone, since he got to the
treasure accessible only via the hall of the mt. king.
also, he's been in giant room (to get eggs), so we can
refer to it. Also also, he's gotten the pearl, so we
know the bivalve is an oyster. AND, the dwarves must
have been activated, since we've found chest.
*/
l10000:
prop[grate]=0;
prop[fissur]=0;
for (i = 1; i <= 6; i++) {
dseen[i]=0;
}
move(troll,0);
move(troll+100,0);
move(troll2,plac[troll]);
move(troll2+100,fixd[troll]);
juggle(chasm);
if(prop[bear] != 3) dstroy(bear);
prop[chain]=0;
fixed[chain]=0;
prop[axe]=0;
fixed[axe]=0;
rspeak(129);
clock1= -1;
closng=1;
goto l19999;
/*
Once he's panicked, and clock2 has run out, we come here
to set up the storage room. The room has two locs,
hardwired as 115 (ne) and 116 (sw). At the ne end, we
place empty bottles, a nursery of plants, a bed of
oysters, a pile of lamps, rods with stars, sleeping
dwarves, and him. At the sw end we place grate over
treasures, snake pit, covey of caged birds, more rods,
and pillows. A mirror stretches across one wall. Many
of the objects come from known locations and/or states
(e.g. the snake is known to have been destroyed and
needn't be carried away from its old "place"), making the
various objects be handled differently. We also drop all
other objects he might be carrying (lest he have some
which could cause trouble, such as the keys). We
describe the flash of light and trundle back.
*/
l11000:
prop[bottle]=put(bottle,115,1);
prop[plant]=put(plant,115,0);
prop[oyster]=put(oyster,115,0);
prop[lamp]=put(lamp,115,0);
prop[rod]=put(rod,115,0);
prop[dwarf]=put(dwarf,115,0);
loc=115;
oldloc=115;
newloc=115;
/* Leave the grate with normal (non-negative property). */
foo=put(grate,116,0);
prop[snake]=put(snake,116,1);
prop[bird]=put(bird,116,1);
prop[cage]=put(cage,116,0);
prop[rod2]=put(rod2,116,0);
prop[pillow]=put(pillow,116,0);
prop[mirror]=put(mirror,115,0);
fixed[mirror]=116;
for (i = 1; i <= 100; i++) {
if(toting(i)) dstroy(i);
}
rspeak(132);
closed=1;
goto l2;
/*
Another way we can force an end to things is by having
the lamp give out. When it gets close, we come here to
warn him. We go to 12000 if the lamp and fresh batteries
are here, in which case we replace the batteries and
continue. 12200 is for other cases of lamp dying. 12400
is when it goes out, and 12600 is if he's wandered
outside and the lamp is used up, in which case we force
him to give up.
*/
l12000:
rspeak(188);
prop[batter]=1;
if(toting(batter)) drop(batter,loc);
limit=limit+2500;
lmwarn=0;
goto l19999;
l12200:
if (lmwarn || !here(lamp)) goto l19999;
lmwarn=1;
spk=187;
if (place[batter] == 0) spk=183;
if (prop[batter] == 1) spk=189;
rspeak(spk);
goto l19999;
l12400:
limit= -1;
prop[lamp]=0;
if (here(lamp)) rspeak(184);
goto l19999;
l12600:
rspeak(185);
gaveup=1;
goto l20000;
/* Oh dear, he's disturbed the dwarves. */
l19000:
rspeak(136);
/*
Exit code.
the present scoring algorithm is as follows:
objective: points: present total possible:
getting well into cave 25 25
each treasure < chest 12 60
treasure chest itself 14 14
each treasure > chest 16 144
surviving (max-num)*10 30
not quitting 4 4
reaching "closng" 25 25
"closed": quit/killed 10
klutzed 25
wrong way 30
success 45 45
came to witt's end 1 1
round out the total 2 2
total: 350
(points can also be deducted for using hints.)
*/
l20000:
score=0;
mxscor=0;
/*
First tally up the treasures. Must be in building and
not broken. Give the poor guy 2 points just for finding
each treasure.
*/
for (i = 50; i <= maxtrs; i++) {
if (ptext[i] != 0) {
k=12;
if (i == chest) k=14;
if (i > chest) k=16;
if (prop[i] >= 0) score=score+2;
if (place[i] == 3 && prop[i] == 0) score=score+k-2;
mxscor=mxscor+k;
}
}
/*
Now look at how he finished and how far he got. maxdie
and numdie tell us how well he survived. gaveup says
whether he exited via quit. dflag will tell us if he
ever got suitably deep into the cave. closng still
indicates whether he reached the endgame. And if he got
as far as "cave closed" (indicated by "closed"), then
bonus is zero for mundane exits or 133, 134, 135 if he
blew it (so to speak).
*/
score=score+(maxdie-numdie)*10;
mxscor=mxscor+maxdie*10;
if (!(scorng || gaveup)) score=score+4;
mxscor=mxscor+4;
if (dflag != 0) score=score+25;
mxscor=mxscor+25;
if (closng) score=score+25;
mxscor=mxscor+25;
if (!closed) goto l20020;
if (bonus == 0) score=score+10;
if (bonus == 135) score=score+25;
if (bonus == 134) score=score+30;
if (bonus == 133) score=score+45;
l20020:
mxscor=mxscor+45;
/* Did he come to Witt's End as he should? */
if (place[magzin] == 108)score++;
mxscor++;
/* Round it off. */
score=score+2;
mxscor=mxscor+2;
/* Deduct points for hints. hints < 4 are special; see
database description. */
for (i = 1; i <= hntmax; i++) {
if (hinted[i]) score=score-hints[i][2];
}
/* Return to score command if that's where we came from. */
if (scorng) goto l8241;
/* That should be good enough. Let's tell him all about it. */
printf ("You scored %d out of a possible %d using %d turn%s.\n",
score, mxscor, turns, turns==1? "": "s");
for (i = 1; i <= clsses; i++) {
if (cval[i] >= score) goto l20210;
}
printf("You just went off my scale!!!\n");
goto l25000;
l20210:
speak(ctext[i]);
if (i == clsses-1) goto l20220;
k=cval[i]+1-score;
printf ("To achieve the next higher rating, you need %d more point%s.\n",
k, k==1? "": "s");
goto l25000;
l20220:
printf ("To achieve the next higher rating would be a neat trick!\n");
printf ("Congratulations!!\n");
l25000:
if (logon) {
/* Log this termination for the interest of other users */
FILE *logfile;
char *ctime();
if ((logfile = fopen ("/usr/games/advlog", "a")) != NULL) {
tvec = time((long *) 0);
cp1 = ctime (&tvec);
/* Assumed format "Mon Jan 99 99:99:99 1999\n\0" */
cp1[10] = '\0';
fprintf (logfile, "%s; %s: %d in %d\n",
cp1 + 4, pwbuf -> pw_name,
score, turns);
}
}
}
/*
* subroutines/functions
* toting(obj) = true if the obj is being carried
* here(obj) = true if the obj is at "loc" (or is being carried)
* at(obj) = true if on either side of two-placed object
* liq(dummy) = object number of liquid in bottle
* liqloc(loc) = object number of liquid (if any) at loc
* bitset(l,n) = true if cond(l) has bit n set (bit 0 is units bit)
* forced(loc) = true if loc moves without asking for input (cond=2)
* dark(dummy) = true if location "loc" is dark
* pct(n) = true n% of the time (n integer from 0 to 100)
*/
toting(ob)
{
return place[ob] == -1;
}
here(ob)
{
return place[ob] == loc || toting (ob);
}
at(ob)
{
return place[ob] == loc || fixed[ob] == loc;
}
liq2(pbotl)
{
int liq2temp;
liq2temp = pbotl/2;
return (1-pbotl)*water + liq2temp * (water+oil);
}
liq()
{
int t;
t = prop[bottle];
return liq2(t>-1-t? t: -1-t);
}
liqloc(where)
{
int t1, t2;
t1 = cond[where] / 2;
t1 = t1 * 2;
t2 = cond[where] / 4;
return liq2 (((t1 % 8)-5)*(t2%2)+1);
}
bitset (mm, n)
{
return (cond[mm] >> n) & 1;
}
forced(where)
{
return cond[where] == 2;
}
dark()
{
return ((cond[loc] & 1) == 0) && (prop[lamp] == 0 || !here(lamp));
}
pct (n)
{
return ran(100) < n;
}
/*
* Place any object anywhere by picking it up and dropping
* it. May already be toting, in which case the carry is
* a no-op. Mustn't pick up objects which are not at any
* loc, since carry wants to remove objects from atloc chains.
*/
move (object, where) {
int source;
if (object <= 100)
source = place[object];
else
source = fixed[object-100];
if (source > 0 && source <= 300)
carry (object, source);
drop (object, where);
}
dstroy (object)
{
move (object, 0);
}
juggle (object)
{
register int ii, jj;
ii = place[object];
jj = fixed [object];
move (object, ii);
move (object+100, jj);
}
put (object, where, pval)
{
move (object, where);
return -1-pval;
}
/*
* Start toting an object, removing it from the list of things at
* its former location. Increment holding unless it was already
* being toted. If object>100 (moving "fixed" second loc)
* don't change place or holdng.
*/
carry (object, where)
{
int tmp;
if (object <= 100) {
if (place[object] == -1) return;
place[object] = -1;
holdng++;
}
if (atloc[where] == object) {
atloc[where] = rlink[object];
return;
}
tmp = atloc[where];
while (rlink[tmp] != object)
tmp = rlink[tmp];
rlink[tmp] = rlink[object];
}
/*
* Place an object at a given loc, prefixing ot onto the atloc list.
* Decrement holdng if the object was being toted.
*/
drop (object, where)
{
if (object > 100)
fixed[object-100] = where;
else
{
if (place[object] == -1) holdng--;
place[object] = where;
}
if (where <= 0) return;
rlink[object] = atloc[where];
atloc[where] = object;
}
fatal(s)
char *s;
{
printf ("\nFatal error: %s\n", s);
exit(1);
}
bug(n)
{
printf ("Bug number %d\n", n);
printf ("Program quits\n");
exit(1);
}
/* Returns a random number between 0 and num-1 inclusive */
ran(num)
{
return (((long) num * rand()) / 32768L);
}
/*
* return 1 if the five-character argument
* is entirely blank, 0 otherwise
*/
blankp(a5)
char *a5;
{
return eqp (a5, " ");
}
/*
* return 1 if a5 and b5 are equal, 0 otherwise.
* The lengths of a5 and b5 are limited to 5,
* but if either contains a null character, it is assumed
* to be padded out to length 5 with blanks.
*/
eqp(a5, b5)
char *a5, *b5;
{
register int z;
register char *aa, *bb;
aa = a5;
bb = b5;
z = 5;
do {
if ((*aa == '\0'? ' ': *aa++) !=
(*bb == '\0'? ' ': *bb++))
return 0;
} while (--z);
return 1;
}
/*
* copy the character string from "source" to "sink". Length is limited
* to 5 characters, and "sink" is blank padded if "source" is shorter.
*/
cpy (sink, source)
register char *source, *sink;
{
register n;
n = 5;
do {
if (*source == '\0')
*sink++ = ' ';
else
*sink++ = *source++;
} while (--n);
}
/*
* Look up id in the vocabulary (atab) and return its "definition"
* (ktab), or -1 if not found. If init is positive, this is an
* initialization call setting up a keyword variable, and not finding
* it constitutes a bug. It also means that only ktab values which taken
* over 1000 equal init may be considered. Thus "steps", which is a
* motion verb as well as an object, may be located as an object. It also
* means the ktab value is taken mod 1000.
*/
vocab (id, init)
char *id;
{
for (i=1; i<=tabsiz; i++) {
if (ktab[i] == -1) goto l2;
if ((init < 0 || init == ktab[i]/1000) && eqp(atab[i], id))
goto l3;
}
bug(21);
l2:
if (init < 0) return -1;
bug(5);
l3:
return init<0? ktab[i]: ktab[i] % 1000;
}
/*
* This program catenates the characters of x and y, which are assumed to
* be 5-character fields, into z. The process stops at the first blank,
* and a null character is appended to the result.
*/
a5toa1 (x, y, z)
char *x, *y, *z;
{
register int n;
n = 5;
do {
if (*x == ' ') {
*z++ = '\0';
return;
}
*z++ = *x++;
} while (--n);
n = 5;
do {
if (*y == ' ') {
*z++ = '\0';
return;
}
*z++ = *y++;
} while (--n);
*z++ = '\0';
}
/*
* Get a command from the terminal. The first word goes into pl and pr,
* and the second word goes into ql and qr. In each case the word is
* padded with blanks to 10 characters; the first 5 will be in the "l"
* variable and the second 5 will be in the "r" variable.
* If hungup is nonzero, indicating he hung up the phone, fudge
* pl, pr, ql, and qr to make it look as if he typed "suspend".
*/
getin (pl, pr, ql, qr)
char *pl, *pr, *ql, *qr;
{
register int p;
cpy (pl, "");
cpy (pr, "");
cpy (ql, "");
cpy (qr, "");
fflush(stdout);
/* Eat blank lines */
if (!hungup) {
while ((p = getchar()) == '\n');
while (p == '!') {
char pl[512];
if (fgets (pl, sizeof(pl), stdin) == 0)
p = EOF;
if (strcmp (pwbuf->pw_name, "games") == 0)
printf ("No Shell escape from \"games\"\n");
else {
system (pl);
printf ("!\n");
fflush (stdout);
}
if (p != EOF)
p = getchar();
}
if (p == EOF) {
cpy (pl, "suspe");
cpy (pr, "nd");
hungup = 1;
return;
}
ungetc (p, stdin);
}
if (snarf (pl, pr) && snarf (ql, qr))
while (getchar() != '\n');
}
/*
* This is a subroutine of getin
*/
snarf (left, right)
char *left, *right;
{
register int n;
char s[10];
register int p;
/* Blank the array */
for (n=0; n<10; n++)
s[n] = ' ';
/* If hung up phone, pretend he said 'suspend' followed by nl */
if (hungup)
goto susp;
/* Skip leading blanks; if nl encountered, return immediately */
while ((p=getchar()) == ' ');
if (p == '\n') return 0;
if (p == EOF) goto susp;
/* Now eat characters until blank or newline */
n = 0;
do {
if (n < 10)
s[n++] = p;
p = getchar();
if (p == EOF) goto susp;
} while (p != ' ' && p != '\n');
/* Break up the string into two five-character components */
cpy (left, s);
cpy (right, s+5);
/* Indicate to caller whether we hit a blank or newline */
return p == ' ';
/* Abnormal exit for EOF */
susp:
cpy (left, "suspe");
cpy (right, "nd");
hungup = 1;
return 0;
}
/*
* Print the n-th "random" message (section 6)
*/
rspeak(n)
{
if (n != 0)
speak (rtext[n]);
}
/*
* Print the message which starts at lines[n]
*/
speak(n)
{
long rec;
do {
rec = lines[n];
if (rec < 0)
rec = -rec;
fseek (caves, rec, 0);
fgets (linebuf, sizeof linebuf, caves);
if (linebuf[0] != '>')
fputs (linebuf, stdout);
} while (++n < linuse && lines[n] >= 0);
}
/*
* Find the skip+1st message from msg and print it. Msg should be
* the index of the inventory message for object
*/
pspeak (msg, skip)
{
int n, q;
q = ptext[msg];
if (skip >= 0)
for (n=0; n<=skip; n++) {
while (lines[++q] >= 0);
}
speak(q);
}
/*
* Print message x, wait for yes/no. If yes, print message y and leave
* "yea" true; else print message z and leave "yea" false.
* If hungup is nonzero, he hung up the phone, so simulate an
* answer of "no".
*/
yes (x, y, z) {
char reply[300];
rspeak(x);
fflush(stdout);
if (scanf ("%s", reply) == EOF)
hungup = 1;
while (hungup == 0 && reply[0] != 'y' && reply[0] != 'n') {
printf ("Please answer the question.\n");
fflush(stdout);
if (scanf ("%s", reply) == EOF)
hungup = 1;
}
if (yea = (reply[0] == 'y' && hungup == 0)) {
if (y != 0)
rspeak(y);
} else if (z != 0)
rspeak (z);
return yea;
}