Revert structurization changes, they broke database compilation...
...bug showing only if adventure.data was absent. We'll need to sneak up on this more carefully.
This commit is contained in:
parent
7e5448e974
commit
484ca4e9fd
11 changed files with 485 additions and 533 deletions
4
COPYING
4
COPYING
|
@ -16,11 +16,11 @@ documentation and/or other materials provided with the distribution.
|
|||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
game.limitED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
game.limitED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
|
|
230
actions1.c
230
actions1.c
|
@ -23,7 +23,7 @@ int action(FILE *input, long STARTAT) {
|
|||
BUG(99);
|
||||
|
||||
L4000: VERB=K;
|
||||
game.spk=ACTSPK[VERB];
|
||||
SPK=ACTSPK[VERB];
|
||||
if(WD2 > 0 && VERB != SAY) return(2800);
|
||||
if(VERB == SAY)OBJ=WD2;
|
||||
if(OBJ > 0) goto L4090;
|
||||
|
@ -134,9 +134,9 @@ L5110: if(K == DWARF && ATDWRF(LOC) > 0) goto L5010;
|
|||
L5120: if(OBJ != PLANT || !AT(PLANT2) || PROP[PLANT2] == 0) goto L5130;
|
||||
OBJ=PLANT2;
|
||||
goto L5010;
|
||||
L5130: if(OBJ != KNIFE || game.knfloc != LOC) goto L5140;
|
||||
game.knfloc= -1;
|
||||
game.spk=116;
|
||||
L5130: if(OBJ != KNIFE || KNFLOC != LOC) goto L5140;
|
||||
KNFLOC= -1;
|
||||
SPK=116;
|
||||
return(2011);
|
||||
L5140: if(OBJ != ROD || !HERE(ROD2)) goto L5190;
|
||||
OBJ=ROD2;
|
||||
|
@ -181,7 +181,7 @@ L9035: WD2=0;
|
|||
|
||||
/* Lock, unlock, no object given. Assume various things if present. */
|
||||
|
||||
L8040: game.spk=28;
|
||||
L8040: SPK=28;
|
||||
if(HERE(CLAM))OBJ=CLAM;
|
||||
if(HERE(OYSTER))OBJ=OYSTER;
|
||||
if(AT(DOOR))OBJ=DOOR;
|
||||
|
@ -193,17 +193,17 @@ L8040: game.spk=28;
|
|||
/* Lock, unlock object. Special stuff for opening clam/oyster and for chain. */
|
||||
|
||||
L9040: if(OBJ == CLAM || OBJ == OYSTER) goto L9046;
|
||||
if(OBJ == DOOR)game.spk=111;
|
||||
if(OBJ == DOOR && PROP[DOOR] == 1)game.spk=54;
|
||||
if(OBJ == CAGE)game.spk=32;
|
||||
if(OBJ == KEYS)game.spk=55;
|
||||
if(OBJ == GRATE || OBJ == CHAIN)game.spk=31;
|
||||
if(game.spk != 31 || !HERE(KEYS)) return(2011);
|
||||
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)) return(2011);
|
||||
if(OBJ == CHAIN) goto L9048;
|
||||
if(!game.closng) goto L9043;
|
||||
if(!CLOSNG) goto L9043;
|
||||
K=130;
|
||||
if(!game.panic)game.clock2=15;
|
||||
game.panic=true;
|
||||
if(!PANIC)CLOCK2=15;
|
||||
PANIC=true;
|
||||
return(2010);
|
||||
|
||||
L9043: K=34+PROP[GRATE];
|
||||
|
@ -215,11 +215,11 @@ L9043: K=34+PROP[GRATE];
|
|||
/* Clam/Oyster. */
|
||||
L9046: K=0;
|
||||
if(OBJ == OYSTER)K=1;
|
||||
game.spk=124+K;
|
||||
if(TOTING(OBJ))game.spk=120+K;
|
||||
if(!TOTING(TRIDNT))game.spk=122+K;
|
||||
if(VERB == LOCK)game.spk=61;
|
||||
if(game.spk != 124) return(2011);
|
||||
SPK=124+K;
|
||||
if(TOTING(OBJ))SPK=120+K;
|
||||
if(!TOTING(TRIDNT))SPK=122+K;
|
||||
if(VERB == LOCK)SPK=61;
|
||||
if(SPK != 124) return(2011);
|
||||
DSTROY(CLAM);
|
||||
DROP(OYSTER,LOC);
|
||||
DROP(PEARL,105);
|
||||
|
@ -227,20 +227,20 @@ L9046: K=0;
|
|||
|
||||
/* Chain. */
|
||||
L9048: if(VERB == LOCK) goto L9049;
|
||||
game.spk=171;
|
||||
if(PROP[BEAR] == 0)game.spk=41;
|
||||
if(PROP[CHAIN] == 0)game.spk=37;
|
||||
if(game.spk != 171) return(2011);
|
||||
SPK=171;
|
||||
if(PROP[BEAR] == 0)SPK=41;
|
||||
if(PROP[CHAIN] == 0)SPK=37;
|
||||
if(SPK != 171) return(2011);
|
||||
PROP[CHAIN]=0;
|
||||
FIXED[CHAIN]=0;
|
||||
if(PROP[BEAR] != 3)PROP[BEAR]=2;
|
||||
FIXED[BEAR]=2-PROP[BEAR];
|
||||
return(2011);
|
||||
|
||||
L9049: game.spk=172;
|
||||
if(PROP[CHAIN] != 0)game.spk=34;
|
||||
if(LOC != PLAC[CHAIN])game.spk=173;
|
||||
if(game.spk != 172) return(2011);
|
||||
L9049: SPK=172;
|
||||
if(PROP[CHAIN] != 0)SPK=34;
|
||||
if(LOC != PLAC[CHAIN])SPK=173;
|
||||
if(SPK != 172) return(2011);
|
||||
PROP[CHAIN]=2;
|
||||
if(TOTING(CHAIN))DROP(CHAIN,LOC);
|
||||
FIXED[CHAIN]= -1;
|
||||
|
@ -248,22 +248,22 @@ L9049: game.spk=172;
|
|||
|
||||
/* Light. Applicable only to lamp and urn. */
|
||||
|
||||
L8070: if(HERE(LAMP) && PROP[LAMP] == 0 && game.limit >= 0)OBJ=LAMP;
|
||||
L8070: if(HERE(LAMP) && PROP[LAMP] == 0 && LIMIT >= 0)OBJ=LAMP;
|
||||
if(HERE(URN) && PROP[URN] == 1)OBJ=OBJ*100+URN;
|
||||
if(OBJ == 0 || OBJ > 100) return(8000);
|
||||
|
||||
L9070: if(OBJ == URN) goto L9073;
|
||||
if(OBJ != LAMP) return(2011);
|
||||
game.spk=184;
|
||||
if(game.limit < 0) return(2011);
|
||||
SPK=184;
|
||||
if(LIMIT < 0) return(2011);
|
||||
PROP[LAMP]=1;
|
||||
RSPEAK(39);
|
||||
if(game.wzdark) return(2000);
|
||||
if(WZDARK) return(2000);
|
||||
return(2012);
|
||||
|
||||
L9073: game.spk=38;
|
||||
L9073: SPK=38;
|
||||
if(PROP[URN] == 0) return(2011);
|
||||
game.spk=209;
|
||||
SPK=209;
|
||||
PROP[URN]=2;
|
||||
return(2011);
|
||||
|
||||
|
@ -275,11 +275,11 @@ L8080: if(HERE(LAMP) && PROP[LAMP] == 1)OBJ=LAMP;
|
|||
|
||||
L9080: if(OBJ == URN) goto L9083;
|
||||
if(OBJ == LAMP) goto L9086;
|
||||
if(OBJ == DRAGON || OBJ == VOLCAN)game.spk=146;
|
||||
if(OBJ == DRAGON || OBJ == VOLCAN)SPK=146;
|
||||
return(2011);
|
||||
|
||||
L9083: PROP[URN]=PROP[URN]/2;
|
||||
game.spk=210;
|
||||
SPK=210;
|
||||
return(2011);
|
||||
|
||||
L9086: PROP[LAMP]=0;
|
||||
|
@ -289,22 +289,22 @@ L9086: PROP[LAMP]=0;
|
|||
|
||||
/* Wave. No effect unless waving rod at fissure or at bird. */
|
||||
|
||||
L9090: if((!TOTING(OBJ)) && (OBJ != ROD || !TOTING(ROD2)))game.spk=29;
|
||||
if(OBJ != ROD || !TOTING(OBJ) || (!HERE(BIRD) && (game.closng || !AT(FISSUR))))
|
||||
L9090: if((!TOTING(OBJ)) && (OBJ != ROD || !TOTING(ROD2)))SPK=29;
|
||||
if(OBJ != ROD || !TOTING(OBJ) || (!HERE(BIRD) && (CLOSNG || !AT(FISSUR))))
|
||||
return(2011);
|
||||
if(HERE(BIRD))game.spk=206+MOD(PROP[BIRD],2);
|
||||
if(game.spk == 206 && LOC == PLACE[STEPS] && PROP[JADE] < 0) goto L9094;
|
||||
if(game.closed) return(18999);
|
||||
if(game.closng || !AT(FISSUR)) return(2011);
|
||||
if(HERE(BIRD))RSPEAK(game.spk);
|
||||
if(HERE(BIRD))SPK=206+MOD(PROP[BIRD],2);
|
||||
if(SPK == 206 && LOC == PLACE[STEPS] && PROP[JADE] < 0) goto L9094;
|
||||
if(CLOSED) return(18999);
|
||||
if(CLOSNG || !AT(FISSUR)) return(2011);
|
||||
if(HERE(BIRD))RSPEAK(SPK);
|
||||
PROP[FISSUR]=1-PROP[FISSUR];
|
||||
PSPEAK(FISSUR,2-PROP[FISSUR]);
|
||||
return(2012);
|
||||
|
||||
L9094: DROP(JADE,LOC);
|
||||
PROP[JADE]=0;
|
||||
game.tally=game.tally-1;
|
||||
game.spk=208;
|
||||
TALLY=TALLY-1;
|
||||
SPK=208;
|
||||
return(2011);
|
||||
|
||||
/* Attack also moved into separate module. */
|
||||
|
@ -317,16 +317,16 @@ L9120: return(attack(input));
|
|||
L9130: if(OBJ == BOTTLE || OBJ == 0)OBJ=LIQ(0);
|
||||
if(OBJ == 0) return(8000);
|
||||
if(!TOTING(OBJ)) return(2011);
|
||||
game.spk=78;
|
||||
SPK=78;
|
||||
if(OBJ != OIL && OBJ != WATER) return(2011);
|
||||
if(HERE(URN) && PROP[URN] == 0) goto L9134;
|
||||
PROP[BOTTLE]=1;
|
||||
PLACE[OBJ]=0;
|
||||
game.spk=77;
|
||||
SPK=77;
|
||||
if(!(AT(PLANT) || AT(DOOR))) return(2011);
|
||||
|
||||
if(AT(DOOR)) goto L9132;
|
||||
game.spk=112;
|
||||
SPK=112;
|
||||
if(OBJ != WATER) return(2011);
|
||||
PSPEAK(PLANT,PROP[PLANT]+3);
|
||||
PROP[PLANT]=MOD(PROP[PLANT]+1,3);
|
||||
|
@ -336,7 +336,7 @@ L9130: if(OBJ == BOTTLE || OBJ == 0)OBJ=LIQ(0);
|
|||
|
||||
L9132: PROP[DOOR]=0;
|
||||
if(OBJ == OIL)PROP[DOOR]=1;
|
||||
game.spk=113+PROP[DOOR];
|
||||
SPK=113+PROP[DOOR];
|
||||
return(2011);
|
||||
|
||||
L9134: OBJ=URN;
|
||||
|
@ -347,13 +347,13 @@ L9134: OBJ=URN;
|
|||
|
||||
L8140: if(!HERE(FOOD)) return(8000);
|
||||
L8142: DSTROY(FOOD);
|
||||
game.spk=72;
|
||||
SPK=72;
|
||||
return(2011);
|
||||
|
||||
L9140: if(OBJ == FOOD) goto L8142;
|
||||
if(OBJ == BIRD || OBJ == SNAKE || OBJ == CLAM || OBJ == OYSTER || OBJ ==
|
||||
DWARF || OBJ == DRAGON || OBJ == TROLL || OBJ == BEAR || OBJ ==
|
||||
OGRE)game.spk=71;
|
||||
OGRE)SPK=71;
|
||||
return(2011);
|
||||
|
||||
/* Drink. If no object, assume water and look for it here. If water is in
|
||||
|
@ -362,29 +362,29 @@ L9140: if(OBJ == FOOD) goto L8142;
|
|||
L9150: if(OBJ == 0 && LIQLOC(LOC) != WATER && (LIQ(0) != WATER || !HERE(BOTTLE)))
|
||||
return(8000);
|
||||
if(OBJ == BLOOD) goto L9153;
|
||||
if(OBJ != 0 && OBJ != WATER)game.spk=110;
|
||||
if(game.spk == 110 || LIQ(0) != WATER || !HERE(BOTTLE)) return(2011);
|
||||
if(OBJ != 0 && OBJ != WATER)SPK=110;
|
||||
if(SPK == 110 || LIQ(0) != WATER || !HERE(BOTTLE)) return(2011);
|
||||
PROP[BOTTLE]=1;
|
||||
PLACE[WATER]=0;
|
||||
game.spk=74;
|
||||
SPK=74;
|
||||
return(2011);
|
||||
|
||||
L9153: DSTROY(BLOOD);
|
||||
PROP[DRAGON]=2;
|
||||
OBJSND[BIRD]=OBJSND[BIRD]+3;
|
||||
game.spk=240;
|
||||
SPK=240;
|
||||
return(2011);
|
||||
|
||||
/* Rub. Yields various snide remarks except for lit urn. */
|
||||
|
||||
L9160: if(OBJ != LAMP)game.spk=76;
|
||||
L9160: if(OBJ != LAMP)SPK=76;
|
||||
if(OBJ != URN || PROP[URN] != 2) return(2011);
|
||||
DSTROY(URN);
|
||||
DROP(AMBER,LOC);
|
||||
PROP[AMBER]=1;
|
||||
game.tally=game.tally-1;
|
||||
TALLY=TALLY-1;
|
||||
DROP(CAVITY,LOC);
|
||||
game.spk=216;
|
||||
SPK=216;
|
||||
return(2011);
|
||||
|
||||
/* Throw moved into separate module. */
|
||||
|
@ -399,24 +399,24 @@ L8180: if(YES(input,22,54,54)) score(1);
|
|||
/* Find. Might be carrying it, or it might be here. Else give caveat. */
|
||||
|
||||
L9190: if(AT(OBJ) || (LIQ(0) == OBJ && AT(BOTTLE)) || K == LIQLOC(LOC) || (OBJ ==
|
||||
DWARF && ATDWRF(LOC) > 0))game.spk=94;
|
||||
if(game.closed)game.spk=138;
|
||||
if(TOTING(OBJ))game.spk=24;
|
||||
DWARF && ATDWRF(LOC) > 0))SPK=94;
|
||||
if(CLOSED)SPK=138;
|
||||
if(TOTING(OBJ))SPK=24;
|
||||
return(2011);
|
||||
|
||||
/* Inventory. If object, treat same as find. Else report on current burden. */
|
||||
|
||||
L8200: game.spk=98;
|
||||
L8200: SPK=98;
|
||||
/* 8201 */ for (I=1; I<=100; I++) {
|
||||
if(I == BEAR || !TOTING(I)) goto L8201;
|
||||
if(game.spk == 98)RSPEAK(99);
|
||||
game.blklin=false;
|
||||
if(SPK == 98)RSPEAK(99);
|
||||
BLKLIN=false;
|
||||
PSPEAK(I,-1);
|
||||
game.blklin=true;
|
||||
game.spk=0;
|
||||
BLKLIN=true;
|
||||
SPK=0;
|
||||
L8201: /*etc*/ ;
|
||||
} /* end loop */
|
||||
if(TOTING(BEAR))game.spk=141;
|
||||
if(TOTING(BEAR))SPK=141;
|
||||
return(2011);
|
||||
|
||||
/* Feed/fill are in the other module. */
|
||||
|
@ -426,18 +426,18 @@ L9220: return(fill());
|
|||
|
||||
/* Blast. No effect unless you've got dynamite, which is a neat trick! */
|
||||
|
||||
L9230: if(PROP[ROD2] < 0 || !game.closed) return(2011);
|
||||
game.bonus=133;
|
||||
if(LOC == 115)game.bonus=134;
|
||||
if(HERE(ROD2))game.bonus=135;
|
||||
RSPEAK(game.bonus);
|
||||
L9230: if(PROP[ROD2] < 0 || !CLOSED) return(2011);
|
||||
BONUS=133;
|
||||
if(LOC == 115)BONUS=134;
|
||||
if(HERE(ROD2))BONUS=135;
|
||||
RSPEAK(BONUS);
|
||||
score(0);
|
||||
|
||||
/* Score. Call scoring routine but tell it to return. */
|
||||
|
||||
L8240: score(-1);
|
||||
SETPRM(1,SCORE,MXSCOR);
|
||||
SETPRM(3,game.turns,game.turns);
|
||||
SETPRM(3,TURNS,TURNS);
|
||||
RSPEAK(259);
|
||||
return(2012);
|
||||
|
||||
|
@ -446,14 +446,14 @@ L8240: score(-1);
|
|||
* WORD ZIPS THE EGGS BACK TO THE GIANT ROOM (UNLESS ALREADY THERE). */
|
||||
|
||||
L8250: K=VOCAB(WD1,3);
|
||||
game.spk=42;
|
||||
if(game.foobar == 1-K) goto L8252;
|
||||
if(game.foobar != 0)game.spk=151;
|
||||
SPK=42;
|
||||
if(FOOBAR == 1-K) goto L8252;
|
||||
if(FOOBAR != 0)SPK=151;
|
||||
return(2011);
|
||||
|
||||
L8252: game.foobar=K;
|
||||
L8252: FOOBAR=K;
|
||||
if(K != 4) return(2009);
|
||||
game.foobar=0;
|
||||
FOOBAR=0;
|
||||
if(PLACE[EGGS] == PLAC[EGGS] || (TOTING(EGGS) && LOC == PLAC[EGGS]))
|
||||
return(2011);
|
||||
/* Bring back troll if we steal the eggs back from him before crossing. */
|
||||
|
@ -468,9 +468,9 @@ L8252: game.foobar=K;
|
|||
|
||||
/* Brief. Intransitive only. Suppress long descriptions after first time. */
|
||||
|
||||
L8260: game.spk=156;
|
||||
game.abbnum=10000;
|
||||
game.detail=3;
|
||||
L8260: SPK=156;
|
||||
ABBNUM=10000;
|
||||
DETAIL=3;
|
||||
return(2011);
|
||||
|
||||
/* Read. Print stuff based on objtxt. Oyster (?) is special case. */
|
||||
|
@ -482,22 +482,22 @@ L8270: for (I=1; I<=100; I++) {
|
|||
|
||||
L9270: if(DARK(0)) goto L5190;
|
||||
if(OBJTXT[OBJ] == 0 || PROP[OBJ] < 0) return(2011);
|
||||
if(OBJ == OYSTER && !game.clshint) goto L9275;
|
||||
if(OBJ == OYSTER && !CLSHNT) goto L9275;
|
||||
PSPEAK(OBJ,OBJTXT[OBJ]+PROP[OBJ]);
|
||||
return(2012);
|
||||
|
||||
L9275: game.clshint=YES(input,192,193,54);
|
||||
L9275: CLSHNT=YES(input,192,193,54);
|
||||
return(2012);
|
||||
|
||||
/* Break. Only works for mirror in repository and, of course, the vase. */
|
||||
|
||||
L9280: if(OBJ == MIRROR)game.spk=148;
|
||||
L9280: if(OBJ == MIRROR)SPK=148;
|
||||
if(OBJ == VASE && PROP[VASE] == 0) goto L9282;
|
||||
if(OBJ != MIRROR || !game.closed) return(2011);
|
||||
game.spk=197;
|
||||
if(OBJ != MIRROR || !CLOSED) return(2011);
|
||||
SPK=197;
|
||||
return(18999);
|
||||
|
||||
L9282: game.spk=198;
|
||||
L9282: SPK=198;
|
||||
if(TOTING(VASE))DROP(VASE,LOC);
|
||||
PROP[VASE]=2;
|
||||
FIXED[VASE]= -1;
|
||||
|
@ -505,18 +505,18 @@ L9282: game.spk=198;
|
|||
|
||||
/* Wake. Only use is to disturb the dwarves. */
|
||||
|
||||
L9290: if(OBJ != DWARF || !game.closed) return(2011);
|
||||
game.spk=199;
|
||||
L9290: if(OBJ != DWARF || !CLOSED) return(2011);
|
||||
SPK=199;
|
||||
return(18999);
|
||||
|
||||
/* Suspend. Offer to save things in a file, but charging some points (so
|
||||
* can't win by using saved games to retry battles or to start over after
|
||||
* learning zzword). */
|
||||
|
||||
L8300: game.spk=201;
|
||||
L8300: SPK=201;
|
||||
RSPEAK(260);
|
||||
if(!YES(input,200,54,54)) return(2012);
|
||||
game.saved=game.saved+5;
|
||||
SAVED=SAVED+5;
|
||||
KK= -1;
|
||||
|
||||
/* This next part is shared with the "resume" code. The two cases are
|
||||
|
@ -534,17 +534,17 @@ L8305: DATIME(I,K);
|
|||
* suspended or resumed are guaranteed to match. If unsure whether a value
|
||||
* needs to be saved, include it. Overkill can't hurt. Pad the last savwds
|
||||
* with junk variables to bring it up to 7 values. */
|
||||
SAVWDS(game.abbnum,game.blklin,game.bonus,game.clock1,game.clock2,game.closed,game.closng);
|
||||
SAVWDS(game.detail,game.dflag,game.dkill,game.dtotal,game.foobar,game.holdng,game.iwest);
|
||||
SAVWDS(game.knfloc,game.limit,LL,game.lmwarn,LOC,game.newloc,game.numdie);
|
||||
SAVWDS(OBJ,game.oldlc2,game.oldloc,game.oldobj,game.panic,game.saved,game.setup);
|
||||
SAVWDS(game.spk,game.tally,game.thresh,game.trndex,game.trnluz,game.turns,OBJTXT[OYSTER]);
|
||||
SAVWDS(VERB,WD1,WD1X,WD2,game.wzdark,game.zzword,OBJSND[BIRD]);
|
||||
SAVWDS(OBJTXT[SIGN],game.clshint,game.novice,K,K,K,K);
|
||||
SAVWDS(ABBNUM,BLKLIN,BONUS,CLOCK1,CLOCK2,CLOSED,CLOSNG);
|
||||
SAVWDS(DETAIL,DFLAG,DKILL,DTOTAL,FOOBAR,HOLDNG,IWEST);
|
||||
SAVWDS(KNFLOC,LIMIT,LL,LMWARN,LOC,NEWLOC,NUMDIE);
|
||||
SAVWDS(OBJ,OLDLC2,OLDLOC,OLDOBJ,PANIC,SAVED,SETUP);
|
||||
SAVWDS(SPK,TALLY,THRESH,TRNDEX,TRNLUZ,TURNS,OBJTXT[OYSTER]);
|
||||
SAVWDS(VERB,WD1,WD1X,WD2,WZDARK,ZZWORD,OBJSND[BIRD]);
|
||||
SAVWDS(OBJTXT[SIGN],CLSHNT,NOVICE,K,K,K,K);
|
||||
SAVARR(ABB,LOCSIZ);
|
||||
SAVARR(ATLOC,LOCSIZ);
|
||||
SAVARR(DLOC,6);
|
||||
SAVARR(game.dseen,6);
|
||||
SAVARR(DSEEN,6);
|
||||
SAVARR(FIXED,100);
|
||||
SAVARR(HINTED,HNTSIZ);
|
||||
SAVARR(HINTLC,HNTSIZ);
|
||||
|
@ -555,7 +555,7 @@ L8305: DATIME(I,K);
|
|||
SAVWRD(KK,K);
|
||||
if(K != 0) goto L8318;
|
||||
K=NUL;
|
||||
game.zzword=RNDVOC(3,game.zzword-MESH*2)+MESH*2;
|
||||
ZZWORD=RNDVOC(3,ZZWORD-MESH*2)+MESH*2;
|
||||
if(KK > 0) return(8);
|
||||
RSPEAK(266);
|
||||
exit(0);
|
||||
|
@ -578,35 +578,35 @@ L8318: RSPEAK(270);
|
|||
|
||||
/* Fly. Snide remarks unless hovering rug is here. */
|
||||
|
||||
L8320: if(PROP[RUG] != 2)game.spk=224;
|
||||
if(!HERE(RUG))game.spk=225;
|
||||
if(game.spk/2 == 112) return(2011);
|
||||
L8320: if(PROP[RUG] != 2)SPK=224;
|
||||
if(!HERE(RUG))SPK=225;
|
||||
if(SPK/2 == 112) return(2011);
|
||||
OBJ=RUG;
|
||||
|
||||
L9320: if(OBJ != RUG) return(2011);
|
||||
game.spk=223;
|
||||
SPK=223;
|
||||
if(PROP[RUG] != 2) return(2011);
|
||||
game.oldlc2=game.oldloc;
|
||||
game.oldloc=LOC;
|
||||
game.newloc=PLACE[RUG]+FIXED[RUG]-LOC;
|
||||
game.spk=226;
|
||||
if(PROP[SAPPH] >= 0)game.spk=227;
|
||||
RSPEAK(game.spk);
|
||||
OLDLC2=OLDLOC;
|
||||
OLDLOC=LOC;
|
||||
NEWLOC=PLACE[RUG]+FIXED[RUG]-LOC;
|
||||
SPK=226;
|
||||
if(PROP[SAPPH] >= 0)SPK=227;
|
||||
RSPEAK(SPK);
|
||||
return(2);
|
||||
|
||||
/* Listen. Intransitive only. Print stuff based on objsnd/locsnd. */
|
||||
|
||||
L8330: game.spk=228;
|
||||
L8330: SPK=228;
|
||||
K=LOCSND[LOC];
|
||||
if(K == 0) goto L8332;
|
||||
RSPEAK(IABS(K));
|
||||
if(K < 0) return(2012);
|
||||
game.spk=0;
|
||||
L8332: SETPRM(1,game.zzword-MESH*2,0);
|
||||
SPK=0;
|
||||
L8332: SETPRM(1,ZZWORD-MESH*2,0);
|
||||
/* 8335 */ for (I=1; I<=100; I++) {
|
||||
if(!HERE(I) || OBJSND[I] == 0 || PROP[I] < 0) goto L8335;
|
||||
PSPEAK(I,OBJSND[I]+PROP[I]);
|
||||
game.spk=0;
|
||||
SPK=0;
|
||||
if(I == BIRD && OBJSND[I]+PROP[I] == 8)DSTROY(BIRD);
|
||||
L8335: /*etc*/ ;
|
||||
} /* end loop */
|
||||
|
@ -618,8 +618,8 @@ L8340: if(!AT(RESER) && LOC != FIXED[RESER]-1) return(2011);
|
|||
PSPEAK(RESER,PROP[RESER]+1);
|
||||
PROP[RESER]=1-PROP[RESER];
|
||||
if(AT(RESER)) return(2012);
|
||||
game.oldlc2=LOC;
|
||||
game.newloc=0;
|
||||
OLDLC2=LOC;
|
||||
NEWLOC=0;
|
||||
RSPEAK(241);
|
||||
return(2);
|
||||
|
||||
|
|
150
actions2.c
150
actions2.c
|
@ -9,17 +9,17 @@
|
|||
|
||||
int carry(void) {
|
||||
if(TOTING(OBJ)) return(2011);
|
||||
game.spk=25;
|
||||
if(OBJ == PLANT && PROP[PLANT] <= 0)game.spk=115;
|
||||
if(OBJ == BEAR && PROP[BEAR] == 1)game.spk=169;
|
||||
if(OBJ == CHAIN && PROP[BEAR] != 0)game.spk=170;
|
||||
if(OBJ == URN)game.spk=215;
|
||||
if(OBJ == CAVITY)game.spk=217;
|
||||
if(OBJ == BLOOD)game.spk=239;
|
||||
if(OBJ == RUG && PROP[RUG] == 2)game.spk=222;
|
||||
if(OBJ == SIGN)game.spk=196;
|
||||
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(OBJ == URN)SPK=215;
|
||||
if(OBJ == CAVITY)SPK=217;
|
||||
if(OBJ == BLOOD)SPK=239;
|
||||
if(OBJ == RUG && PROP[RUG] == 2)SPK=222;
|
||||
if(OBJ == SIGN)SPK=196;
|
||||
if(OBJ != MESSAG) goto L9011;
|
||||
game.spk=190;
|
||||
SPK=190;
|
||||
DSTROY(MESSAG);
|
||||
L9011: if(FIXED[OBJ] != 0) return(2011);
|
||||
if(OBJ != WATER && OBJ != OIL) goto L9017;
|
||||
|
@ -27,16 +27,16 @@ L9011: if(FIXED[OBJ] != 0) return(2011);
|
|||
OBJ=BOTTLE;
|
||||
if(HERE(BOTTLE) && LIQ(0) == K) goto L9017;
|
||||
if(TOTING(BOTTLE) && PROP[BOTTLE] == 1) return(fill());
|
||||
if(PROP[BOTTLE] != 1)game.spk=105;
|
||||
if(!TOTING(BOTTLE))game.spk=104;
|
||||
if(PROP[BOTTLE] != 1)SPK=105;
|
||||
if(!TOTING(BOTTLE))SPK=104;
|
||||
return(2011);
|
||||
L9017: game.spk=92;
|
||||
if(game.holdng >= 7) return(2011);
|
||||
L9017: SPK=92;
|
||||
if(HOLDNG >= 7) return(2011);
|
||||
if(OBJ != BIRD || PROP[BIRD] == 1 || -1-PROP[BIRD] == 1) goto L9014;
|
||||
if(PROP[BIRD] == 2) goto L9015;
|
||||
if(!TOTING(CAGE))game.spk=27;
|
||||
if(TOTING(ROD))game.spk=26;
|
||||
if(game.spk/2 == 13) return(2011);
|
||||
if(!TOTING(CAGE))SPK=27;
|
||||
if(TOTING(ROD))SPK=26;
|
||||
if(SPK/2 == 13) return(2011);
|
||||
PROP[BIRD]=1;
|
||||
L9014: if((OBJ == BIRD || OBJ == CAGE) && (PROP[BIRD] == 1 || -1-PROP[BIRD] ==
|
||||
1))CARRY(BIRD+CAGE-OBJ,LOC);
|
||||
|
@ -48,7 +48,7 @@ L9014: if((OBJ == BIRD || OBJ == CAGE) && (PROP[BIRD] == 1 || -1-PROP[BIRD] ==
|
|||
PROP[CAVITY]=1;
|
||||
return(2009);
|
||||
|
||||
L9015: game.spk=238;
|
||||
L9015: SPK=238;
|
||||
DSTROY(BIRD);
|
||||
return(2011);
|
||||
}
|
||||
|
@ -63,7 +63,7 @@ int discard(bool just_do_it) {
|
|||
if(!TOTING(OBJ)) return(2011);
|
||||
if(OBJ != BIRD || !HERE(SNAKE)) goto L9023;
|
||||
RSPEAK(30);
|
||||
if(game.closed) return(19000);
|
||||
if(CLOSED) return(19000);
|
||||
DSTROY(SNAKE);
|
||||
/* SET PROP FOR USE BY TRAVEL OPTIONS */
|
||||
PROP[SNAKE]=1;
|
||||
|
@ -83,11 +83,11 @@ L9023: if(!(GSTONE(OBJ) && AT(CAVITY) && PROP[CAVITY] != 0)) goto L9024;
|
|||
PROP[CAVITY]=0;
|
||||
if(!HERE(RUG) || !((OBJ == EMRALD && PROP[RUG] != 2) || (OBJ == RUBY &&
|
||||
PROP[RUG] == 2))) goto L9021;
|
||||
game.spk=219;
|
||||
if(TOTING(RUG))game.spk=220;
|
||||
if(OBJ == RUBY)game.spk=221;
|
||||
RSPEAK(game.spk);
|
||||
if(game.spk == 220) goto L9021;
|
||||
SPK=219;
|
||||
if(TOTING(RUG))SPK=220;
|
||||
if(OBJ == RUBY)SPK=221;
|
||||
RSPEAK(SPK);
|
||||
if(SPK == 220) goto L9021;
|
||||
K=2-PROP[RUG];
|
||||
PROP[RUG]=K;
|
||||
if(K == 2)K=PLAC[SAPPH];
|
||||
|
@ -149,26 +149,26 @@ int attack(FILE *input) {
|
|||
if(HERE(CLAM) || HERE(OYSTER))OBJ=100*OBJ+CLAM;
|
||||
if(OBJ > 100) return(8000);
|
||||
L9124: if(OBJ != BIRD) goto L9125;
|
||||
game.spk=137;
|
||||
if(game.closed) return(2011);
|
||||
SPK=137;
|
||||
if(CLOSED) return(2011);
|
||||
DSTROY(BIRD);
|
||||
PROP[BIRD]=0;
|
||||
game.spk=45;
|
||||
SPK=45;
|
||||
L9125: if(OBJ != VEND) goto L9126;
|
||||
PSPEAK(VEND,PROP[VEND]+2);
|
||||
PROP[VEND]=3-PROP[VEND];
|
||||
return(2012);
|
||||
|
||||
L9126: if(OBJ == 0)game.spk=44;
|
||||
if(OBJ == CLAM || OBJ == OYSTER)game.spk=150;
|
||||
if(OBJ == SNAKE)game.spk=46;
|
||||
if(OBJ == DWARF)game.spk=49;
|
||||
if(OBJ == DWARF && game.closed) return(19000);
|
||||
if(OBJ == DRAGON)game.spk=167;
|
||||
if(OBJ == TROLL)game.spk=157;
|
||||
if(OBJ == OGRE)game.spk=203;
|
||||
L9126: 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) return(19000);
|
||||
if(OBJ == DRAGON)SPK=167;
|
||||
if(OBJ == TROLL)SPK=157;
|
||||
if(OBJ == OGRE)SPK=203;
|
||||
if(OBJ == OGRE && I > 0) goto L9128;
|
||||
if(OBJ == BEAR)game.spk=165+(PROP[BEAR]+1)/2;
|
||||
if(OBJ == BEAR)SPK=165+(PROP[BEAR]+1)/2;
|
||||
if(OBJ != DRAGON || PROP[DRAGON] != 0) return(2011);
|
||||
/* 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
|
||||
|
@ -195,7 +195,7 @@ L9126: if(OBJ == 0)game.spk=44;
|
|||
K=NUL;
|
||||
return(8);
|
||||
|
||||
L9128: RSPEAK(game.spk);
|
||||
L9128: RSPEAK(SPK);
|
||||
RSPEAK(6);
|
||||
DSTROY(OGRE);
|
||||
K=0;
|
||||
|
@ -203,10 +203,10 @@ L9128: RSPEAK(game.spk);
|
|||
if(DLOC[I] != LOC) goto L9129;
|
||||
K=K+1;
|
||||
DLOC[I]=61;
|
||||
game.dseen[I]=false;
|
||||
DSEEN[I]=false;
|
||||
L9129: /*etc*/ ;
|
||||
} /* end loop */
|
||||
game.spk=game.spk+1+1/K;
|
||||
SPK=SPK+1+1/K;
|
||||
return(2011);
|
||||
}
|
||||
|
||||
|
@ -222,30 +222,30 @@ int throw(FILE *cmdin) {
|
|||
if(OBJ != AXE) return(discard(false));
|
||||
I=ATDWRF(LOC);
|
||||
if(I > 0) goto L9172;
|
||||
game.spk=152;
|
||||
SPK=152;
|
||||
if(AT(DRAGON) && PROP[DRAGON] == 0) goto L9175;
|
||||
game.spk=158;
|
||||
SPK=158;
|
||||
if(AT(TROLL)) goto L9175;
|
||||
game.spk=203;
|
||||
SPK=203;
|
||||
if(AT(OGRE)) goto L9175;
|
||||
if(HERE(BEAR) && PROP[BEAR] == 0) goto L9176;
|
||||
OBJ=0;
|
||||
return(attack(cmdin));
|
||||
|
||||
L9172: game.spk=48;
|
||||
if(RAN(7) < game.dflag) goto L9175;
|
||||
game.dseen[I]=false;
|
||||
L9172: SPK=48;
|
||||
if(RAN(7) < DFLAG) goto L9175;
|
||||
DSEEN[I]=false;
|
||||
DLOC[I]=0;
|
||||
game.spk=47;
|
||||
game.dkill=game.dkill+1;
|
||||
if(game.dkill == 1)game.spk=149;
|
||||
L9175: RSPEAK(game.spk);
|
||||
SPK=47;
|
||||
DKILL=DKILL+1;
|
||||
if(DKILL == 1)SPK=149;
|
||||
L9175: RSPEAK(SPK);
|
||||
DROP(AXE,LOC);
|
||||
K=NUL;
|
||||
return(8);
|
||||
|
||||
/* This'll teach him to throw the axe at the bear! */
|
||||
L9176: game.spk=164;
|
||||
L9176: SPK=164;
|
||||
DROP(AXE,LOC);
|
||||
FIXED[AXE]= -1;
|
||||
PROP[AXE]=1;
|
||||
|
@ -256,7 +256,7 @@ L9176: game.spk=164;
|
|||
L9177: OBJ=BEAR;
|
||||
return(feed());
|
||||
|
||||
L9178: game.spk=159;
|
||||
L9178: SPK=159;
|
||||
/* Snarf a treasure for the troll. */
|
||||
DROP(OBJ,0);
|
||||
MOVE(TROLL,0);
|
||||
|
@ -272,41 +272,41 @@ L9178: game.spk=159;
|
|||
|
||||
int feed() {
|
||||
if(OBJ != BIRD) goto L9212;
|
||||
game.spk=100;
|
||||
SPK=100;
|
||||
return(2011);
|
||||
|
||||
L9212: if(OBJ != SNAKE && OBJ != DRAGON && OBJ != TROLL) goto L9213;
|
||||
game.spk=102;
|
||||
if(OBJ == DRAGON && PROP[DRAGON] != 0)game.spk=110;
|
||||
if(OBJ == TROLL)game.spk=182;
|
||||
if(OBJ != SNAKE || game.closed || !HERE(BIRD)) return(2011);
|
||||
game.spk=101;
|
||||
SPK=102;
|
||||
if(OBJ == DRAGON && PROP[DRAGON] != 0)SPK=110;
|
||||
if(OBJ == TROLL)SPK=182;
|
||||
if(OBJ != SNAKE || CLOSED || !HERE(BIRD)) return(2011);
|
||||
SPK=101;
|
||||
DSTROY(BIRD);
|
||||
PROP[BIRD]=0;
|
||||
return(2011);
|
||||
|
||||
L9213: if(OBJ != DWARF) goto L9214;
|
||||
if(!HERE(FOOD)) return(2011);
|
||||
game.spk=103;
|
||||
game.dflag=game.dflag+2;
|
||||
SPK=103;
|
||||
DFLAG=DFLAG+2;
|
||||
return(2011);
|
||||
|
||||
L9214: if(OBJ != BEAR) goto L9215;
|
||||
if(PROP[BEAR] == 0)game.spk=102;
|
||||
if(PROP[BEAR] == 3)game.spk=110;
|
||||
if(PROP[BEAR] == 0)SPK=102;
|
||||
if(PROP[BEAR] == 3)SPK=110;
|
||||
if(!HERE(FOOD)) return(2011);
|
||||
DSTROY(FOOD);
|
||||
PROP[BEAR]=1;
|
||||
FIXED[AXE]=0;
|
||||
PROP[AXE]=0;
|
||||
game.spk=168;
|
||||
SPK=168;
|
||||
return(2011);
|
||||
|
||||
L9215: if(OBJ != OGRE) goto L9216;
|
||||
if(HERE(FOOD))game.spk=202;
|
||||
if(HERE(FOOD))SPK=202;
|
||||
return(2011);
|
||||
|
||||
L9216: game.spk=14;
|
||||
L9216: SPK=14;
|
||||
return(2011);
|
||||
}
|
||||
|
||||
|
@ -317,33 +317,33 @@ int fill() {
|
|||
if(OBJ == URN) goto L9224;
|
||||
if(OBJ != 0 && OBJ != BOTTLE) return(2011);
|
||||
if(OBJ == 0 && !HERE(BOTTLE)) return(8000);
|
||||
game.spk=107;
|
||||
if(LIQLOC(LOC) == 0)game.spk=106;
|
||||
if(HERE(URN) && PROP[URN] != 0)game.spk=214;
|
||||
if(LIQ(0) != 0)game.spk=105;
|
||||
if(game.spk != 107) return(2011);
|
||||
SPK=107;
|
||||
if(LIQLOC(LOC) == 0)SPK=106;
|
||||
if(HERE(URN) && PROP[URN] != 0)SPK=214;
|
||||
if(LIQ(0) != 0)SPK=105;
|
||||
if(SPK != 107) return(2011);
|
||||
PROP[BOTTLE]=MOD(COND[LOC],4)/2*2;
|
||||
K=LIQ(0);
|
||||
if(TOTING(BOTTLE))PLACE[K]= -1;
|
||||
if(K == OIL)game.spk=108;
|
||||
if(K == OIL)SPK=108;
|
||||
return(2011);
|
||||
|
||||
L9222: game.spk=29;
|
||||
if(LIQLOC(LOC) == 0)game.spk=144;
|
||||
L9222: SPK=29;
|
||||
if(LIQLOC(LOC) == 0)SPK=144;
|
||||
if(LIQLOC(LOC) == 0 || !TOTING(VASE)) return(2011);
|
||||
RSPEAK(145);
|
||||
PROP[VASE]=2;
|
||||
FIXED[VASE]= -1;
|
||||
return(discard(true));
|
||||
|
||||
L9224: game.spk=213;
|
||||
L9224: SPK=213;
|
||||
if(PROP[URN] != 0) return(2011);
|
||||
game.spk=144;
|
||||
SPK=144;
|
||||
K=LIQ(0);
|
||||
if(K == 0 || !HERE(BOTTLE)) return(2011);
|
||||
PLACE[K]=0;
|
||||
PROP[BOTTLE]=1;
|
||||
if(K == OIL)PROP[URN]=1;
|
||||
game.spk=211+PROP[URN];
|
||||
SPK=211+PROP[URN];
|
||||
return(2011);
|
||||
}
|
||||
|
|
|
@ -1861,14 +1861,14 @@
|
|||
142 though you get partial credit just for locating it. You lose points
|
||||
142 for getting killed, or for quitting, though the former costs you more.
|
||||
142 There are also points based on how much (if any) of the cave you've
|
||||
142 managed to explore; in particular, there is a large game.bonus just for
|
||||
142 managed to explore; in particular, there is a large bonus just for
|
||||
142 getting in (to distinguish the beginners from the rest of the pack),
|
||||
142 and there are other ways to determine whether you've been through some
|
||||
142 of the more harrowing sections. If you think you've found all the
|
||||
142 treasures, just keep exploring for a while. If nothing interesting
|
||||
142 happens, you haven't found them all yet. If something interesting
|
||||
142 *DOES* happen (incidentally, there *ARE* ways to hasten things along),
|
||||
142 it means you're getting a game.bonus and have an opportunity to garner many
|
||||
142 it means you're getting a bonus and have an opportunity to garner many
|
||||
142 more points in the Master's section. I may occasionally offer hints
|
||||
142 if you seem to be having trouble. If I do, I'll warn you in advance
|
||||
142 how much it will affect your score to accept the hints. Finally, to
|
||||
|
|
2
funcs.h
2
funcs.h
|
@ -28,7 +28,7 @@
|
|||
#define FOREST(LOC) ((LOC) >= 145 && (LOC) <= 166)
|
||||
#define VOCWRD(LETTRS,SECT) (VOCAB(MAKEWD(LETTRS),SECT))
|
||||
|
||||
/* The following two functions were added to fix a bug (game.clock1 decremented
|
||||
/* The following two functions were added to fix a bug (CLOCK1 decremented
|
||||
* while in forest). They should probably be replaced by using another
|
||||
* "cond" bit. For now, however, a quick fix... OUTSID(LOC) is true if
|
||||
* LOC is outside, INDEEP(LOC) is true if LOC is "deep" in the cave (hall
|
||||
|
|
104
init.c
104
init.c
|
@ -218,7 +218,7 @@ L1001: /*etc*/ ;
|
|||
/* Start new data section. Sect is the section number. */
|
||||
|
||||
L1002: SECT=GETNUM(OPENED);
|
||||
game.oldloc= -1;
|
||||
OLDLOC= -1;
|
||||
switch (SECT) { case 0: return(0); case 1: goto L1004; case 2: goto
|
||||
L1004; case 3: goto L1030; case 4: goto L1040; case 5: goto L1004;
|
||||
case 6: goto L1004; case 7: goto L1050; case 8: goto L1060; case
|
||||
|
@ -241,8 +241,8 @@ L1006: KK=KK+1;
|
|||
LINES[KK]=GETTXT(false,false,false,KK);
|
||||
if(LINES[KK] != -1) goto L1006;
|
||||
LINES[LINUSE]=KK;
|
||||
if(LOC == game.oldloc) goto L1005;
|
||||
game.oldloc=LOC;
|
||||
if(LOC == OLDLOC) goto L1005;
|
||||
OLDLOC=LOC;
|
||||
LINES[LINUSE]= -KK;
|
||||
if(SECT == 14) goto L1014;
|
||||
if(SECT == 10) goto L1012;
|
||||
|
@ -278,20 +278,20 @@ L1014: TRNVLS=TRNVLS+1;
|
|||
|
||||
/* The stuff for section 3 is encoded here. Each "from-location" gets a
|
||||
* contiguous section of the "TRAVEL" array. Each entry in travel is
|
||||
* game.newloc*1000 + KEYWORD (from section 4, motion verbs), and is negated if
|
||||
* 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: LOC=GETNUM(OPENED);
|
||||
if(LOC == -1) goto L1002;
|
||||
game.newloc=GETNUM(NULL);
|
||||
NEWLOC=GETNUM(NULL);
|
||||
if(KEY[LOC] != 0) goto L1033;
|
||||
KEY[LOC]=TRVS;
|
||||
goto L1035;
|
||||
L1033: TRVS--; TRAVEL[TRVS]= -TRAVEL[TRVS]; TRVS++;
|
||||
L1035: L=GETNUM(NULL);
|
||||
if(L == 0) goto L1039;
|
||||
TRAVEL[TRVS]=game.newloc*1000+L;
|
||||
TRAVEL[TRVS]=NEWLOC*1000+L;
|
||||
TRVS=TRVS+1;
|
||||
if(TRVS == TRVSIZ)BUG(3);
|
||||
goto L1035;
|
||||
|
@ -417,14 +417,14 @@ L1106: /*etc*/ ;
|
|||
|
||||
/* 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. game.tally keeps track of how many are not yet found, so we know
|
||||
* described. TALLY keeps track of how many are not yet found, so we know
|
||||
* when to close the cave. */
|
||||
|
||||
MAXTRS=79;
|
||||
game.tally=0;
|
||||
TALLY=0;
|
||||
for (I=50; I<=MAXTRS; I++) {
|
||||
if(PTEXT[I] != 0)PROP[I]= -1;
|
||||
game.tally=game.tally-PROP[I];
|
||||
TALLY=TALLY-PROP[I];
|
||||
} /* end loop */
|
||||
|
||||
/* Clear the hint stuff. HINTLC(I) is how long he's been at LOC with cond bit
|
||||
|
@ -519,7 +519,7 @@ L1106: /*etc*/ ;
|
|||
* 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.
|
||||
* game.dflag controls the level of activation of all this:
|
||||
* 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
|
||||
|
@ -532,9 +532,9 @@ L1106: /*etc*/ ;
|
|||
CHLOC=114;
|
||||
CHLOC2=140;
|
||||
for (I=1; I<=6; I++) {
|
||||
game.dseen[I]=false;
|
||||
DSEEN[I]=false;
|
||||
} /* end loop */
|
||||
game.dflag=0;
|
||||
DFLAG=0;
|
||||
DLOC[1]=19;
|
||||
DLOC[2]=27;
|
||||
DLOC[3]=33;
|
||||
|
@ -544,56 +544,56 @@ L1106: /*etc*/ ;
|
|||
DALTLC=18;
|
||||
|
||||
/* Other random flags and counters, as follows:
|
||||
* game.abbnum How often we should print non-abbreviated descriptions
|
||||
* game.bonus Used to determine amount of bonus if he reaches closing
|
||||
* game.clock1 Number of turns from finding last treasure till closing
|
||||
* game.clock2 Number of turns from first warning till blinding flash
|
||||
* ABBNUM How often we should print non-abbreviated descriptions
|
||||
* 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
|
||||
* CONDS Min value for cond(loc) if loc has any hints
|
||||
* game.detail How often we've said "not allowed to give more detail"
|
||||
* game.dkill Number of dwarves killed (unused in scoring, needed for msg)
|
||||
* game.foobar Current progress in saying "FEE FIE FOE FOO".
|
||||
* game.holdng Number of objects being carried
|
||||
* DETAIL How often we've said "not allowed to give more detail"
|
||||
* DKILL Number of dwarves killed (unused in scoring, needed for msg)
|
||||
* FOOBAR Current progress in saying "FEE FIE FOE FOO".
|
||||
* HOLDNG Number of objects being carried
|
||||
* IGO How many times he's said "go XXX" instead of "XXX"
|
||||
* game.iwest How many times he's said "west" instead of "w"
|
||||
* game.knfloc 0 if no knife here, loc if knife here, -1 after caveat
|
||||
* game.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
|
||||
* LIMIT Lifetime of lamp (not set here)
|
||||
* MAXDIE Number of reincarnation messages available (up to 5)
|
||||
* game.numdie Number of times killed so far
|
||||
* game.thresh Next #turns threshhold (-1 if none)
|
||||
* game.trndex Index in TRNVAL of next threshhold (section 14 of database)
|
||||
* game.trnluz # points lost so far due to number of turns used
|
||||
* game.turns Tallies how many commands he's given (ignores yes/no)
|
||||
* NUMDIE Number of times killed so far
|
||||
* THRESH Next #turns threshhold (-1 if none)
|
||||
* TRNDEX Index in TRNVAL of next threshhold (section 14 of database)
|
||||
* TRNLUZ # points lost so far due to number of turns used
|
||||
* TURNS Tallies how many commands he's given (ignores yes/no)
|
||||
* Logicals were explained earlier */
|
||||
|
||||
game.turns=0;
|
||||
game.trndex=1;
|
||||
game.thresh= -1;
|
||||
if(TRNVLS > 0)game.thresh=MOD(TRNVAL[1],100000)+1;
|
||||
game.trnluz=0;
|
||||
game.lmwarn=false;
|
||||
TURNS=0;
|
||||
TRNDEX=1;
|
||||
THRESH= -1;
|
||||
if(TRNVLS > 0)THRESH=MOD(TRNVAL[1],100000)+1;
|
||||
TRNLUZ=0;
|
||||
LMWARN=false;
|
||||
IGO=0;
|
||||
game.iwest=0;
|
||||
game.knfloc=0;
|
||||
game.detail=0;
|
||||
game.abbnum=5;
|
||||
IWEST=0;
|
||||
KNFLOC=0;
|
||||
DETAIL=0;
|
||||
ABBNUM=5;
|
||||
for (I=0; I<=4; I++) {
|
||||
{long x = 2*I+81; if(RTEXT[x] != 0)MAXDIE=I+1;}
|
||||
} /* end loop */
|
||||
game.numdie=0;
|
||||
game.holdng=0;
|
||||
game.dkill=0;
|
||||
game.foobar=0;
|
||||
game.bonus=0;
|
||||
game.clock1=30;
|
||||
game.clock2=50;
|
||||
NUMDIE=0;
|
||||
HOLDNG=0;
|
||||
DKILL=0;
|
||||
FOOBAR=0;
|
||||
BONUS=0;
|
||||
CLOCK1=30;
|
||||
CLOCK2=50;
|
||||
CONDS=SETBIT(11);
|
||||
game.saved=0;
|
||||
game.closng=false;
|
||||
game.panic=false;
|
||||
game.closed=false;
|
||||
game.clshint=false;
|
||||
game.novice=false;
|
||||
game.setup=1;
|
||||
SAVED=0;
|
||||
CLOSNG=false;
|
||||
PANIC=false;
|
||||
CLOSED=false;
|
||||
CLSHNT=false;
|
||||
NOVICE=false;
|
||||
SETUP=1;
|
||||
|
||||
/* if we can ever think of how, we should save it at this point */
|
||||
|
||||
|
|
366
main.c
366
main.c
|
@ -11,34 +11,35 @@
|
|||
|
||||
#include "misc.h"
|
||||
|
||||
long ABB[186], ATAB[331], ATLOC[186],
|
||||
DLOC[7], FIXED[101],
|
||||
long ABB[186], ATAB[331], ATLOC[186], BLKLIN = true, DFLAG,
|
||||
DLOC[7], FIXED[101], HOLDNG,
|
||||
KTAB[331], *LINES, LINK[201], LNLENG, LNPOSN,
|
||||
PARMS[26], PLACE[101], PTEXT[101], RTEXT[278],
|
||||
TABSIZ = 330;
|
||||
SETUP = 0, TABSIZ = 330;
|
||||
signed char INLINE[LINESIZE+1], MAP1[129], MAP2[129];
|
||||
|
||||
long ACTSPK[36], AMBER, ATTACK, AXE, BACK, BATTER, BEAR, BIRD, BLOOD,
|
||||
long ABBNUM, ACTSPK[36], AMBER, ATTACK, AXE, BACK, BATTER, BEAR, BIRD, BLOOD, BONUS,
|
||||
BOTTLE, CAGE, CAVE, CAVITY, CHAIN, CHASM, CHEST, CHLOC, CHLOC2,
|
||||
CLAM, CLSMAX = 12, CLSSES,
|
||||
COINS, COND[186], CONDS, CTEXT[13], CVAL[13], DALTLC,
|
||||
DOOR, DPRSSN, DRAGON, DWARF, EGGS,
|
||||
EMRALD, ENTER, ENTRNC, FIND, FISSUR, FIXD[101], FOOD,
|
||||
CLAM, CLOCK1, CLOCK2, CLOSED, CLOSNG, CLSHNT, CLSMAX = 12, CLSSES,
|
||||
COINS, COND[186], CONDS, CTEXT[13], CVAL[13], DALTLC, DETAIL,
|
||||
DKILL, DOOR, DPRSSN, DRAGON, DSEEN[7], DTOTAL, DWARF, EGGS,
|
||||
EMRALD, ENTER, ENTRNC, FIND, FISSUR, FIXD[101], FOOBAR, FOOD,
|
||||
GRATE, HINT, HINTED[21], HINTLC[21], HINTS[21][5], HNTMAX,
|
||||
HNTSIZ = 20, I, INVENT, IGO, J, JADE, K, K2, KEY[186], KEYS, KK,
|
||||
KNIFE, KQ, L, LAMP, LINSIZ = 12500, LINUSE, LL,
|
||||
LOC, LOCK, LOCSIZ = 185, LOCSND[186], LOOK, LTEXT[186],
|
||||
HNTSIZ = 20, I, INVENT, IGO, IWEST, J, JADE, K, K2, KEY[186], KEYS, KK,
|
||||
KNFLOC, KNIFE, KQ, L, LAMP, LIMIT, LINSIZ = 12500, LINUSE, LL,
|
||||
LMWARN, LOC, LOCK, LOCSIZ = 185, LOCSND[186], LOOK, LTEXT[186],
|
||||
MAGZIN, MAXDIE, MAXTRS, MESH = 123456789,
|
||||
MESSAG, MIRROR, MXSCOR, NUGGET, NUL, OBJ, OBJSND[101],
|
||||
OBJTXT[101], ODLOC[7], OGRE, OIL, OYSTER,
|
||||
PEARL, PILLOW, PLAC[101], PLANT, PLANT2, PROP[101], PYRAM,
|
||||
RESER, ROD, ROD2, RTXSIZ = 277, RUBY, RUG, SAPPH, SAY,
|
||||
SCORE, SECT, SIGN, SNAKE, STEPS, STEXT[186], STICK,
|
||||
STREAM, TABNDX, THROW, TK[21], TRAVEL[886], TRIDNT,
|
||||
TRNSIZ = 5, TRNVAL[6], TRNVLS, TROLL, TROLL2, TRVS,
|
||||
TRVSIZ = 885, TTEXT[6], URN, V1, V2, VASE, VEND, VERB,
|
||||
VOLCAN, VRBSIZ = 35, VRSION = 25, WATER, WD1, WD1X, WD2, WD2X;
|
||||
struct game_t game = {.blklin = true};
|
||||
MESSAG, MIRROR, MXSCOR,
|
||||
NEWLOC, NOVICE, NUGGET, NUL, NUMDIE, OBJ, OBJSND[101],
|
||||
OBJTXT[101], ODLOC[7], OGRE, OIL, OLDLC2, OLDLOC, OLDOBJ, OYSTER,
|
||||
PANIC, PEARL, PILLOW, PLAC[101], PLANT, PLANT2, PROP[101], PYRAM,
|
||||
RESER, ROD, ROD2, RTXSIZ = 277, RUBY, RUG, SAPPH, SAVED, SAY,
|
||||
SCORE, SECT, SIGN, SNAKE, SPK, STEPS, STEXT[186], STICK,
|
||||
STREAM, TABNDX, TALLY, THRESH, THROW, TK[21], TRAVEL[886], TRIDNT,
|
||||
TRNDEX, TRNLUZ, TRNSIZ = 5, TRNVAL[6], TRNVLS, TROLL, TROLL2, TRVS,
|
||||
TRVSIZ = 885, TTEXT[6], TURNS, URN, V1, V2, VASE, VEND, VERB,
|
||||
VOLCAN, VRBSIZ = 35, VRSION = 25, WATER, WD1, WD1X, WD2, WD2X,
|
||||
WZDARK = false, ZZWORD;
|
||||
FILE *logfp;
|
||||
bool oldstyle = false;
|
||||
|
||||
|
@ -82,13 +83,13 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
/* Logical variables:
|
||||
*
|
||||
* game.closed says whether we're all the way closed
|
||||
* game.closng says whether it's closing time yet
|
||||
* game.clshint says whether he's read the clue in the endgame
|
||||
* game.lmwarn says whether he's been warned about lamp going dim
|
||||
* game.novice says whether he asked for instructions at start-up
|
||||
* game.panic says whether he's found out he's trapped in the cave
|
||||
* game.wzdark says whether the loc he's leaving was dark */
|
||||
* CLOSED says whether we're all the way closed
|
||||
* CLOSNG says whether it's closing time yet
|
||||
* CLSHNT says whether he's read the clue in the endgame
|
||||
* LMWARN says whether he's been warned about lamp going dim
|
||||
* NOVICE says whether he asked for instructions at start-up
|
||||
* PANIC says whether he's found out he's trapped in the cave
|
||||
* WZDARK says whether the loc he's leaving was dark */
|
||||
|
||||
#include "funcs.h"
|
||||
|
||||
|
@ -101,8 +102,8 @@ int main(int argc, char *argv[]) {
|
|||
}
|
||||
|
||||
MAP2[1] = 0;
|
||||
if(!game.setup)initialise();
|
||||
if(game.setup > 0) goto L1;
|
||||
if(!SETUP)initialise();
|
||||
if(SETUP > 0) goto L1;
|
||||
|
||||
/* Unlike earlier versions, adventure is no longer restartable. (This
|
||||
* lets us get away with modifying things such as OBJSND(BIRD) without
|
||||
|
@ -114,14 +115,14 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
/* Start-up, dwarf stuff */
|
||||
|
||||
L1: game.setup= -1;
|
||||
L1: SETUP= -1;
|
||||
I=RAN(-1);
|
||||
game.zzword=RNDVOC(3,0)+MESH*2;
|
||||
game.novice=YES(stdin, 65,1,0);
|
||||
game.newloc=1;
|
||||
ZZWORD=RNDVOC(3,0)+MESH*2;
|
||||
NOVICE=YES(stdin, 65,1,0);
|
||||
NEWLOC=1;
|
||||
LOC=1;
|
||||
game.limit=330;
|
||||
if(game.novice)game.limit=1000;
|
||||
LIMIT=330;
|
||||
if(NOVICE)LIMIT=1000;
|
||||
|
||||
for (;;) {
|
||||
do_command(stdin);
|
||||
|
@ -132,47 +133,47 @@ static void do_command(FILE *cmdin) {
|
|||
|
||||
/* Can't leave cave once it's closing (except by main office). */
|
||||
|
||||
L2: if(!OUTSID(game.newloc) || game.newloc == 0 || !game.closng) goto L71;
|
||||
L2: if(!OUTSID(NEWLOC) || NEWLOC == 0 || !CLOSNG) goto L71;
|
||||
RSPEAK(130);
|
||||
game.newloc=LOC;
|
||||
if(!game.panic)game.clock2=15;
|
||||
game.panic=true;
|
||||
NEWLOC=LOC;
|
||||
if(!PANIC)CLOCK2=15;
|
||||
PANIC=true;
|
||||
|
||||
/* 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). */
|
||||
|
||||
L71: if(game.newloc == LOC || FORCED(LOC) || CNDBIT(LOC,3)) goto L74;
|
||||
L71: if(NEWLOC == LOC || FORCED(LOC) || CNDBIT(LOC,3)) goto L74;
|
||||
/* 73 */ for (I=1; I<=5; I++) {
|
||||
if(ODLOC[I] != game.newloc || !game.dseen[I]) goto L73;
|
||||
game.newloc=LOC;
|
||||
if(ODLOC[I] != NEWLOC || !DSEEN[I]) goto L73;
|
||||
NEWLOC=LOC;
|
||||
RSPEAK(2);
|
||||
goto L74;
|
||||
L73: /*etc*/ ;
|
||||
} /* end loop */
|
||||
L74: LOC=game.newloc;
|
||||
L74: 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 game.newloc is forbidden to pirate (in particular, if it's beyond the troll
|
||||
* 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) || CNDBIT(game.newloc,3)) goto L2000;
|
||||
if(game.dflag != 0) goto L6000;
|
||||
if(INDEEP(LOC))game.dflag=1;
|
||||
if(LOC == 0 || FORCED(LOC) || CNDBIT(NEWLOC,3)) goto L2000;
|
||||
if(DFLAG != 0) goto L6000;
|
||||
if(INDEEP(LOC))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. */
|
||||
|
||||
L6000: if(game.dflag != 1) goto L6010;
|
||||
L6000: if(DFLAG != 1) goto L6010;
|
||||
if(!INDEEP(LOC) || (PCT(95) && (!CNDBIT(LOC,4) || PCT(85)))) goto L2000;
|
||||
game.dflag=2;
|
||||
DFLAG=2;
|
||||
for (I=1; I<=2; I++) {
|
||||
J=1+RAN(5);
|
||||
if(PCT(50))DLOC[J]=0;
|
||||
|
@ -190,7 +191,7 @@ L6000: if(game.dflag != 1) goto L6010;
|
|||
* 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. */
|
||||
|
||||
L6010: game.dtotal=0;
|
||||
L6010: DTOTAL=0;
|
||||
ATTACK=0;
|
||||
STICK=0;
|
||||
/* 6030 */ for (I=1; I<=6; I++) {
|
||||
|
@ -200,13 +201,13 @@ L6010: game.dtotal=0;
|
|||
KK=DLOC[I];
|
||||
KK=KEY[KK];
|
||||
if(KK == 0) goto L6016;
|
||||
L6012: game.newloc=MOD(IABS(TRAVEL[KK])/1000,1000);
|
||||
L6012: NEWLOC=MOD(IABS(TRAVEL[KK])/1000,1000);
|
||||
{long x = J-1;
|
||||
if(game.newloc > 300 || !INDEEP(game.newloc) || game.newloc == ODLOC[I] || (J > 1 &&
|
||||
game.newloc == TK[x]) || J >= 20 || game.newloc == DLOC[I] ||
|
||||
FORCED(game.newloc) || (I == 6 && CNDBIT(game.newloc,3)) ||
|
||||
if(NEWLOC > 300 || !INDEEP(NEWLOC) || NEWLOC == ODLOC[I] || (J > 1 &&
|
||||
NEWLOC == TK[x]) || J >= 20 || NEWLOC == DLOC[I] ||
|
||||
FORCED(NEWLOC) || (I == 6 && CNDBIT(NEWLOC,3)) ||
|
||||
IABS(TRAVEL[KK])/1000000 == 100) goto L6014;}
|
||||
TK[J]=game.newloc;
|
||||
TK[J]=NEWLOC;
|
||||
J=J+1;
|
||||
L6014: KK=KK+1;
|
||||
{long x = KK-1; if(TRAVEL[x] >= 0) goto L6012;}
|
||||
|
@ -215,8 +216,8 @@ L6016: TK[J]=ODLOC[I];
|
|||
J=1+RAN(J);
|
||||
ODLOC[I]=DLOC[I];
|
||||
DLOC[I]=TK[J];
|
||||
game.dseen[I]=(game.dseen[I] && INDEEP(LOC)) || (DLOC[I] == LOC || ODLOC[I] == LOC);
|
||||
if(!game.dseen[I]) goto L6030;
|
||||
DSEEN[I]=(DSEEN[I] && INDEEP(LOC)) || (DLOC[I] == LOC || ODLOC[I] == LOC);
|
||||
if(!DSEEN[I]) goto L6030;
|
||||
DLOC[I]=LOC;
|
||||
if(I != 6) goto L6027;
|
||||
|
||||
|
@ -233,7 +234,7 @@ L6016: TK[J]=ODLOC[I];
|
|||
if(TOTING(J)) goto L6021;
|
||||
L6020: if(HERE(J))K=1;
|
||||
} /* end loop */
|
||||
if(game.tally == 1 && K == 0 && PLACE[CHEST] == 0 && HERE(LAMP) && PROP[LAMP]
|
||||
if(TALLY == 1 && K == 0 && PLACE[CHEST] == 0 && HERE(LAMP) && PROP[LAMP]
|
||||
== 1) goto L6025;
|
||||
if(ODLOC[6] != DLOC[6] && PCT(20))RSPEAK(127);
|
||||
goto L6030;
|
||||
|
@ -251,7 +252,7 @@ L6023: /*etc*/ ;
|
|||
} /* end loop */
|
||||
L6024: DLOC[6]=CHLOC;
|
||||
ODLOC[6]=CHLOC;
|
||||
game.dseen[6]=false;
|
||||
DSEEN[6]=false;
|
||||
goto L6030;
|
||||
|
||||
L6025: RSPEAK(186);
|
||||
|
@ -261,11 +262,11 @@ L6025: RSPEAK(186);
|
|||
|
||||
/* This threatening little dwarf is in the room with him! */
|
||||
|
||||
L6027: game.dtotal=game.dtotal+1;
|
||||
L6027: DTOTAL=DTOTAL+1;
|
||||
if(ODLOC[I] != DLOC[I]) goto L6030;
|
||||
ATTACK=ATTACK+1;
|
||||
if(game.knfloc >= 0)game.knfloc=LOC;
|
||||
if(RAN(1000) < 95*(game.dflag-2))STICK=STICK+1;
|
||||
if(KNFLOC >= 0)KNFLOC=LOC;
|
||||
if(RAN(1000) < 95*(DFLAG-2))STICK=STICK+1;
|
||||
L6030: /*etc*/ ;
|
||||
} /* end loop */
|
||||
|
||||
|
@ -273,11 +274,11 @@ L6030: /*etc*/ ;
|
|||
* Note that various of the "knife" messages must have specific relative
|
||||
* positions in the RSPEAK database. */
|
||||
|
||||
if(game.dtotal == 0) goto L2000;
|
||||
SETPRM(1,game.dtotal,0);
|
||||
RSPEAK(4+1/game.dtotal);
|
||||
if(DTOTAL == 0) goto L2000;
|
||||
SETPRM(1,DTOTAL,0);
|
||||
RSPEAK(4+1/DTOTAL);
|
||||
if(ATTACK == 0) goto L2000;
|
||||
if(game.dflag == 2)game.dflag=3;
|
||||
if(DFLAG == 2)DFLAG=3;
|
||||
SETPRM(1,ATTACK,0);
|
||||
K=6;
|
||||
if(ATTACK > 1)K=250;
|
||||
|
@ -285,7 +286,7 @@ L6030: /*etc*/ ;
|
|||
SETPRM(1,STICK,0);
|
||||
RSPEAK(K+1+2/(1+STICK));
|
||||
if(STICK == 0) goto L2000;
|
||||
game.oldlc2=LOC;
|
||||
OLDLC2=LOC;
|
||||
goto L99;
|
||||
|
||||
|
||||
|
@ -299,15 +300,15 @@ L6030: /*etc*/ ;
|
|||
|
||||
L2000: if(LOC == 0) goto L99;
|
||||
KK=STEXT[LOC];
|
||||
if(MOD(ABB[LOC],game.abbnum) == 0 || KK == 0)KK=LTEXT[LOC];
|
||||
if(MOD(ABB[LOC],ABBNUM) == 0 || KK == 0)KK=LTEXT[LOC];
|
||||
if(FORCED(LOC) || !DARK(0)) goto L2001;
|
||||
if(game.wzdark && PCT(35)) goto L90;
|
||||
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) && !game.closng)RSPEAK(7);
|
||||
if(LOC == 33 && PCT(25) && !CLOSNG)RSPEAK(7);
|
||||
|
||||
/* Print out descriptions of objects at this location. If not closing and
|
||||
* property value is negative, tally off another treasure. Rug is special
|
||||
|
@ -323,10 +324,10 @@ L2004: if(I == 0) goto L2012;
|
|||
if(OBJ > 100)OBJ=OBJ-100;
|
||||
if(OBJ == STEPS && TOTING(NUGGET)) goto L2008;
|
||||
if(PROP[OBJ] >= 0) goto L2006;
|
||||
if(game.closed) goto L2008;
|
||||
if(CLOSED) goto L2008;
|
||||
PROP[OBJ]=0;
|
||||
if(OBJ == RUG || OBJ == CHAIN)PROP[OBJ]=1;
|
||||
game.tally=game.tally-1;
|
||||
TALLY=TALLY-1;
|
||||
/* Note: There used to be a test here to see whether the player had blown it
|
||||
* so badly that he could never ever see the remaining treasures, and if so
|
||||
* the lamp was zapped to 35 turns. But the tests were too simple-minded;
|
||||
|
@ -345,11 +346,11 @@ L2008: I=LINK[I];
|
|||
goto L2004;
|
||||
|
||||
L2009: K=54;
|
||||
L2010: game.spk=K;
|
||||
L2011: RSPEAK(game.spk);
|
||||
L2010: SPK=K;
|
||||
L2011: RSPEAK(SPK);
|
||||
|
||||
L2012: VERB=0;
|
||||
game.oldobj=OBJ;
|
||||
OLDOBJ=OBJ;
|
||||
OBJ=0;
|
||||
|
||||
/* Check if this loc is eligible for any hints. If been here long enough,
|
||||
|
@ -370,40 +371,40 @@ L2602: /*etc*/ ;
|
|||
* 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 game.clock1 unless well into cave (and not at Y2). */
|
||||
* tick CLOCK1 unless well into cave (and not at Y2). */
|
||||
|
||||
L2603: if(!game.closed) goto L2605;
|
||||
L2603: 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];
|
||||
} /* end loop */
|
||||
L2605: game.wzdark=DARK(0);
|
||||
if(game.knfloc > 0 && game.knfloc != LOC)game.knfloc=0;
|
||||
L2605: WZDARK=DARK(0);
|
||||
if(KNFLOC > 0 && KNFLOC != LOC)KNFLOC=0;
|
||||
I=RAN(1);
|
||||
GETIN(cmdin, WD1,WD1X,WD2,WD2X);
|
||||
|
||||
/* Every input, check "game.foobar" flag. If zero, nothing's going on. If pos,
|
||||
/* 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. */
|
||||
|
||||
L2607: game.foobar=(game.foobar>0 ? -game.foobar : 0);
|
||||
game.turns=game.turns+1;
|
||||
if(game.turns != game.thresh) goto L2608;
|
||||
SPEAK(TTEXT[game.trndex]);
|
||||
game.trnluz=game.trnluz+TRNVAL[game.trndex]/100000;
|
||||
game.trndex=game.trndex+1;
|
||||
game.thresh= -1;
|
||||
if(game.trndex <= TRNVLS)game.thresh=MOD(TRNVAL[game.trndex],100000)+1;
|
||||
L2607: FOOBAR=(FOOBAR>0 ? -FOOBAR : 0);
|
||||
TURNS=TURNS+1;
|
||||
if(TURNS != THRESH) goto L2608;
|
||||
SPEAK(TTEXT[TRNDEX]);
|
||||
TRNLUZ=TRNLUZ+TRNVAL[TRNDEX]/100000;
|
||||
TRNDEX=TRNDEX+1;
|
||||
THRESH= -1;
|
||||
if(TRNDEX <= TRNVLS)THRESH=MOD(TRNVAL[TRNDEX],100000)+1;
|
||||
L2608: if(VERB == SAY && WD2 > 0)VERB=0;
|
||||
if(VERB == SAY) goto L4090;
|
||||
if(game.tally == 0 && INDEEP(LOC) && LOC != 33)game.clock1=game.clock1-1;
|
||||
if(game.clock1 == 0) goto L10000;
|
||||
if(game.clock1 < 0)game.clock2=game.clock2-1;
|
||||
if(game.clock2 == 0) goto L11000;
|
||||
if(PROP[LAMP] == 1)game.limit=game.limit-1;
|
||||
if(game.limit <= 30 && HERE(BATTER) && PROP[BATTER] == 0 && HERE(LAMP)) goto
|
||||
if(TALLY == 0 && INDEEP(LOC) && LOC != 33)CLOCK1=CLOCK1-1;
|
||||
if(CLOCK1 == 0) goto L10000;
|
||||
if(CLOCK1 < 0)CLOCK2=CLOCK2-1;
|
||||
if(CLOCK2 == 0) goto L11000;
|
||||
if(PROP[LAMP] == 1)LIMIT=LIMIT-1;
|
||||
if(LIMIT <= 30 && HERE(BATTER) && PROP[BATTER] == 0 && HERE(LAMP)) goto
|
||||
L12000;
|
||||
if(game.limit == 0) goto L12400;
|
||||
if(game.limit <= 30) goto L12200;
|
||||
if(LIMIT == 0) goto L12400;
|
||||
if(LIMIT <= 30) goto L12200;
|
||||
L19999: K=43;
|
||||
if(LIQLOC(LOC) == WATER)K=70;
|
||||
V1=VOCAB(WD1,-1);
|
||||
|
@ -416,8 +417,8 @@ L19999: K=43;
|
|||
L2610: if(V1 == 1000+CAGE && V2 == 1000+BIRD && HERE(CAGE) &&
|
||||
HERE(BIRD))WD1=MAKEWD(301200308);
|
||||
L2620: if(WD1 != MAKEWD(23051920)) goto L2625;
|
||||
game.iwest=game.iwest+1;
|
||||
if(game.iwest == 10)RSPEAK(17);
|
||||
IWEST=IWEST+1;
|
||||
if(IWEST == 10)RSPEAK(17);
|
||||
L2625: if(WD1 != MAKEWD( 715) || WD2 == 0) goto L2630;
|
||||
IGO=IGO+1;
|
||||
if(IGO == 10)RSPEAK(276);
|
||||
|
@ -476,23 +477,21 @@ L8000: SETPRM(1,WD1,WD1X);
|
|||
|
||||
/* Figure out the new location
|
||||
*
|
||||
* Given the current location in "LOC", and a motion verb number in
|
||||
* "K", put the new location in "game.newloc". The current loc is
|
||||
* saved in "game.oldloc" in case he wants to retreat. The current
|
||||
* game.oldloc is saved in game.oldlc2, in case he dies. (if he
|
||||
* does, game.newloc will be limbo, and game.oldloc will be what
|
||||
* killed him, so we need game.oldlc2, which is the last place he was
|
||||
* safe.) */
|
||||
* 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];
|
||||
game.newloc=LOC;
|
||||
NEWLOC=LOC;
|
||||
if(KK == 0)BUG(26);
|
||||
if(K == NUL) return;
|
||||
if(K == BACK) goto L20;
|
||||
if(K == LOOK) goto L30;
|
||||
if(K == CAVE) goto L40;
|
||||
game.oldlc2=game.oldloc;
|
||||
game.oldloc=LOC;
|
||||
OLDLC2=OLDLOC;
|
||||
OLDLOC=LOC;
|
||||
|
||||
L9: LL=IABS(TRAVEL[KK]);
|
||||
if(MOD(LL,1000) == 1 || MOD(LL,1000) == K) goto L10;
|
||||
|
@ -501,34 +500,34 @@ L9: LL=IABS(TRAVEL[KK]);
|
|||
goto L9;
|
||||
|
||||
L10: LL=LL/1000;
|
||||
L11: game.newloc=LL/1000;
|
||||
K=MOD(game.newloc,100);
|
||||
if(game.newloc <= 300) goto L13;
|
||||
if(PROP[K] != game.newloc/100-3) goto L16;
|
||||
L11: NEWLOC=LL/1000;
|
||||
K=MOD(NEWLOC,100);
|
||||
if(NEWLOC <= 300) goto L13;
|
||||
if(PROP[K] != NEWLOC/100-3) goto L16;
|
||||
L12: if(TRAVEL[KK] < 0)BUG(25);
|
||||
KK=KK+1;
|
||||
game.newloc=IABS(TRAVEL[KK])/1000;
|
||||
if(game.newloc == LL) goto L12;
|
||||
LL=game.newloc;
|
||||
NEWLOC=IABS(TRAVEL[KK])/1000;
|
||||
if(NEWLOC == LL) goto L12;
|
||||
LL=NEWLOC;
|
||||
goto L11;
|
||||
|
||||
L13: if(game.newloc <= 100) goto L14;
|
||||
if(TOTING(K) || (game.newloc > 200 && AT(K))) goto L16;
|
||||
L13: if(NEWLOC <= 100) goto L14;
|
||||
if(TOTING(K) || (NEWLOC > 200 && AT(K))) goto L16;
|
||||
goto L12;
|
||||
|
||||
L14: if(game.newloc != 0 && !PCT(game.newloc)) goto L12;
|
||||
L16: game.newloc=MOD(LL,1000);
|
||||
if(game.newloc <= 300) return;
|
||||
if(game.newloc <= 500) goto L30000;
|
||||
RSPEAK(game.newloc-500);
|
||||
game.newloc=LOC;
|
||||
L14: if(NEWLOC != 0 && !PCT(NEWLOC)) goto L12;
|
||||
L16: NEWLOC=MOD(LL,1000);
|
||||
if(NEWLOC <= 300) return;
|
||||
if(NEWLOC <= 500) goto L30000;
|
||||
RSPEAK(NEWLOC-500);
|
||||
NEWLOC=LOC;
|
||||
return;
|
||||
|
||||
/* Special motions come here. Labelling convention: statement numbers NNNXX
|
||||
* (XX=00-99) are used for special case number NNN (NNN=301-500). */
|
||||
|
||||
L30000: game.newloc=game.newloc-300;
|
||||
switch (game.newloc) { case 1: goto L30100; case 2: goto L30200; case 3: goto
|
||||
L30000: NEWLOC=NEWLOC-300;
|
||||
switch (NEWLOC) { case 1: goto L30100; case 2: goto L30200; case 3: goto
|
||||
L30300; }
|
||||
BUG(20);
|
||||
|
||||
|
@ -536,9 +535,9 @@ L30000: game.newloc=game.newloc-300;
|
|||
* table must include "useless" entries going through passage, which can never
|
||||
* be used for actual motion, but can be spotted by "go back". */
|
||||
|
||||
L30100: game.newloc=99+100-LOC;
|
||||
if(game.holdng == 0 || (game.holdng == 1 && TOTING(EMRALD))) return;
|
||||
game.newloc=LOC;
|
||||
L30100: NEWLOC=99+100-LOC;
|
||||
if(HOLDNG == 0 || (HOLDNG == 1 && TOTING(EMRALD))) return;
|
||||
NEWLOC=LOC;
|
||||
RSPEAK(117);
|
||||
return;
|
||||
|
||||
|
@ -563,31 +562,30 @@ L30300: if(PROP[TROLL] != 1) goto L30310;
|
|||
MOVE(TROLL,PLAC[TROLL]);
|
||||
MOVE(TROLL+100,FIXD[TROLL]);
|
||||
JUGGLE(CHASM);
|
||||
game.newloc=LOC;
|
||||
NEWLOC=LOC;
|
||||
return;
|
||||
|
||||
L30310: game.newloc=PLAC[TROLL]+FIXD[TROLL]-LOC;
|
||||
L30310: NEWLOC=PLAC[TROLL]+FIXD[TROLL]-LOC;
|
||||
if(PROP[TROLL] == 0)PROP[TROLL]=1;
|
||||
if(!TOTING(BEAR)) return;
|
||||
RSPEAK(162);
|
||||
PROP[CHASM]=1;
|
||||
PROP[TROLL]=2;
|
||||
DROP(BEAR,game.newloc);
|
||||
DROP(BEAR,NEWLOC);
|
||||
FIXED[BEAR]= -1;
|
||||
PROP[BEAR]=3;
|
||||
game.oldlc2=game.newloc;
|
||||
OLDLC2=NEWLOC;
|
||||
goto L99;
|
||||
|
||||
/* End of specials. */
|
||||
|
||||
/* Handle "go back". Look for verb which goes from LOC to
|
||||
* game.oldloc, or to game.oldlc2 If game.oldloc has forced-motion.
|
||||
* K2 saves entry -> forced loc -> previous loc. */
|
||||
/* 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=game.oldloc;
|
||||
if(FORCED(K))K=game.oldlc2;
|
||||
game.oldlc2=game.oldloc;
|
||||
game.oldloc=LOC;
|
||||
L20: K=OLDLOC;
|
||||
if(FORCED(K))K=OLDLC2;
|
||||
OLDLC2=OLDLOC;
|
||||
OLDLOC=LOC;
|
||||
K2=0;
|
||||
if(K == LOC)K2=91;
|
||||
if(CNDBIT(LOC,4))K2=274;
|
||||
|
@ -616,9 +614,9 @@ L25: K=MOD(IABS(TRAVEL[KK]),1000);
|
|||
/* 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(game.detail < 3)RSPEAK(15);
|
||||
game.detail=game.detail+1;
|
||||
game.wzdark=false;
|
||||
L30: if(DETAIL < 3)RSPEAK(15);
|
||||
DETAIL=DETAIL+1;
|
||||
WZDARK=false;
|
||||
ABB[LOC]=0;
|
||||
return;
|
||||
|
||||
|
@ -631,15 +629,15 @@ L40: K=58;
|
|||
|
||||
/* Non-applicable motion. Various messages depending on word given. */
|
||||
|
||||
L50: game.spk=12;
|
||||
if(K >= 43 && K <= 50)game.spk=52;
|
||||
if(K == 29 || K == 30)game.spk=52;
|
||||
if(K == 7 || K == 36 || K == 37)game.spk=10;
|
||||
if(K == 11 || K == 19)game.spk=11;
|
||||
if(VERB == FIND || VERB == INVENT)game.spk=59;
|
||||
if(K == 62 || K == 65)game.spk=42;
|
||||
if(K == 17)game.spk=80;
|
||||
RSPEAK(game.spk);
|
||||
L50: SPK=12;
|
||||
if(K >= 43 && K <= 50)SPK=52;
|
||||
if(K == 29 || K == 30)SPK=52;
|
||||
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);
|
||||
return;
|
||||
|
||||
|
||||
|
@ -653,7 +651,7 @@ L50: game.spk=12;
|
|||
* 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 game.oldlc2
|
||||
* 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
|
||||
|
@ -661,38 +659,38 @@ L50: game.spk=12;
|
|||
* 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!).
|
||||
* game.oldloc is zapped so he can't just "retreat". */
|
||||
* 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);
|
||||
game.oldlc2=LOC;
|
||||
OLDLC2=LOC;
|
||||
|
||||
/* Okay, he's dead. Let's get on with it. */
|
||||
|
||||
L99: if(game.closng) goto L95;
|
||||
game.numdie=game.numdie+1;
|
||||
if(!YES(cmdin,79+game.numdie*2,80+game.numdie*2,54)) score(0);
|
||||
if(game.numdie == MAXDIE) score(0);
|
||||
L99: if(CLOSNG) goto L95;
|
||||
NUMDIE=NUMDIE+1;
|
||||
if(!YES(cmdin,79+NUMDIE*2,80+NUMDIE*2,54)) score(0);
|
||||
if(NUMDIE == MAXDIE) score(0);
|
||||
PLACE[WATER]=0;
|
||||
PLACE[OIL]=0;
|
||||
if(TOTING(LAMP))PROP[LAMP]=0;
|
||||
/* 98 */ for (J=1; J<=100; J++) {
|
||||
I=101-J;
|
||||
if(!TOTING(I)) goto L98;
|
||||
K=game.oldlc2;
|
||||
K=OLDLC2;
|
||||
if(I == LAMP)K=1;
|
||||
DROP(I,K);
|
||||
L98: /*etc*/ ;
|
||||
} /* end loop */
|
||||
LOC=3;
|
||||
game.oldloc=LOC;
|
||||
OLDLOC=LOC;
|
||||
goto L2000;
|
||||
|
||||
/* He died during closing time. No resurrection. Tally up a death and exit. */
|
||||
|
||||
L95: RSPEAK(131);
|
||||
game.numdie=game.numdie+1;
|
||||
NUMDIE=NUMDIE+1;
|
||||
score(0);
|
||||
|
||||
|
||||
|
@ -719,7 +717,7 @@ L40010: HINTLC[HINT]=0;
|
|||
SETPRM(1,HINTS[HINT][2],HINTS[HINT][2]);
|
||||
RSPEAK(261);
|
||||
HINTED[HINT]=YES(cmdin,175,HINTS[HINT][4],54);
|
||||
if(HINTED[HINT] && game.limit > 30)game.limit=game.limit+30*HINTS[HINT][2];
|
||||
if(HINTED[HINT] && LIMIT > 30)LIMIT=LIMIT+30*HINTS[HINT][2];
|
||||
L40020: HINTLC[HINT]=0;
|
||||
L40030: goto L2602;
|
||||
|
||||
|
@ -728,13 +726,13 @@ L40030: goto L2602;
|
|||
L40100: if(PROP[GRATE] == 0 && !HERE(KEYS)) goto L40010;
|
||||
goto L40020;
|
||||
|
||||
L40200: if(PLACE[BIRD] == LOC && TOTING(ROD) && game.oldobj == BIRD) goto L40010;
|
||||
L40200: if(PLACE[BIRD] == LOC && TOTING(ROD) && OLDOBJ == BIRD) goto L40010;
|
||||
goto L40030;
|
||||
|
||||
L40300: if(HERE(SNAKE) && !HERE(BIRD)) goto L40010;
|
||||
goto L40020;
|
||||
|
||||
L40400: if(ATLOC[LOC] == 0 && ATLOC[game.oldloc] == 0 && ATLOC[game.oldlc2] == 0 && game.holdng >
|
||||
L40400: if(ATLOC[LOC] == 0 && ATLOC[OLDLOC] == 0 && ATLOC[OLDLC2] == 0 && HOLDNG >
|
||||
1) goto L40010;
|
||||
goto L40020;
|
||||
|
||||
|
@ -743,10 +741,10 @@ L40500: if(PROP[EMRALD] != -1 && PROP[PYRAM] == -1) goto L40010;
|
|||
|
||||
L40600: goto L40010;
|
||||
|
||||
L40700: if(game.dflag == 0) goto L40010;
|
||||
L40700: if(DFLAG == 0) goto L40010;
|
||||
goto L40020;
|
||||
|
||||
L40800: if(ATLOC[LOC] == 0 && ATLOC[game.oldloc] == 0 && ATLOC[game.oldlc2] == 0) goto
|
||||
L40800: if(ATLOC[LOC] == 0 && ATLOC[OLDLOC] == 0 && ATLOC[OLDLC2] == 0) goto
|
||||
L40010;
|
||||
goto L40030;
|
||||
|
||||
|
@ -755,7 +753,7 @@ L40900: I=ATDWRF(LOC);
|
|||
if(HERE(OGRE) && I == 0) goto L40010;
|
||||
goto L40030;
|
||||
|
||||
L41000: if(game.tally == 1 && PROP[JADE] < 0) goto L40010;
|
||||
L41000: if(TALLY == 1 && PROP[JADE] < 0) goto L40010;
|
||||
goto L40020;
|
||||
|
||||
|
||||
|
@ -797,7 +795,7 @@ L41000: if(game.tally == 1 && PROP[JADE] < 0) goto L40010;
|
|||
L10000: PROP[GRATE]=0;
|
||||
PROP[FISSUR]=0;
|
||||
for (I=1; I<=6; I++) {
|
||||
game.dseen[I]=false;
|
||||
DSEEN[I]=false;
|
||||
DLOC[I]=0;
|
||||
} /* end loop */
|
||||
MOVE(TROLL,0);
|
||||
|
@ -811,8 +809,8 @@ L10000: PROP[GRATE]=0;
|
|||
PROP[AXE]=0;
|
||||
FIXED[AXE]=0;
|
||||
RSPEAK(129);
|
||||
game.clock1= -1;
|
||||
game.closng=true;
|
||||
CLOCK1= -1;
|
||||
CLOSNG=true;
|
||||
goto L19999;
|
||||
|
||||
/* Once he's panicked, and clock2 has run out, we come here to set up the
|
||||
|
@ -835,8 +833,8 @@ L11000: PROP[BOTTLE]=PUT(BOTTLE,115,1);
|
|||
PROP[ROD]=PUT(ROD,115,0);
|
||||
PROP[DWARF]=PUT(DWARF,115,0);
|
||||
LOC=115;
|
||||
game.oldloc=115;
|
||||
game.newloc=115;
|
||||
OLDLOC=115;
|
||||
NEWLOC=115;
|
||||
|
||||
/* Leave the grate with normal (non-negative) property. Reuse sign. */
|
||||
|
||||
|
@ -857,7 +855,7 @@ L11000: PROP[BOTTLE]=PUT(BOTTLE,115,1);
|
|||
} /* end loop */
|
||||
|
||||
RSPEAK(132);
|
||||
game.closed=true;
|
||||
CLOSED=true;
|
||||
return;
|
||||
|
||||
/* Another way we can force an end to things is by having the lamp give out.
|
||||
|
@ -869,26 +867,26 @@ L11000: PROP[BOTTLE]=PUT(BOTTLE,115,1);
|
|||
L12000: RSPEAK(188);
|
||||
PROP[BATTER]=1;
|
||||
if(TOTING(BATTER))DROP(BATTER,LOC);
|
||||
game.limit=game.limit+2500;
|
||||
game.lmwarn=false;
|
||||
LIMIT=LIMIT+2500;
|
||||
LMWARN=false;
|
||||
goto L19999;
|
||||
|
||||
L12200: if(game.lmwarn || !HERE(LAMP)) goto L19999;
|
||||
game.lmwarn=true;
|
||||
game.spk=187;
|
||||
if(PLACE[BATTER] == 0)game.spk=183;
|
||||
if(PROP[BATTER] == 1)game.spk=189;
|
||||
RSPEAK(game.spk);
|
||||
L12200: if(LMWARN || !HERE(LAMP)) goto L19999;
|
||||
LMWARN=true;
|
||||
SPK=187;
|
||||
if(PLACE[BATTER] == 0)SPK=183;
|
||||
if(PROP[BATTER] == 1)SPK=189;
|
||||
RSPEAK(SPK);
|
||||
goto L19999;
|
||||
|
||||
L12400: game.limit= -1;
|
||||
L12400: LIMIT= -1;
|
||||
PROP[LAMP]=0;
|
||||
if(HERE(LAMP))RSPEAK(184);
|
||||
goto L19999;
|
||||
|
||||
/* Oh dear, he's disturbed the dwarves. */
|
||||
|
||||
L18999: RSPEAK(game.spk);
|
||||
L18999: RSPEAK(SPK);
|
||||
L19000: RSPEAK(136);
|
||||
score(0);
|
||||
}
|
||||
|
|
50
main.h
50
main.h
|
@ -2,57 +2,9 @@
|
|||
|
||||
#define LINESIZE 100
|
||||
|
||||
extern long ABB[], ATAB[], ATLOC[], DLOC[], FIXED[],
|
||||
extern long ABB[], ATAB[], ATLOC[], BLKLIN, DFLAG, DLOC[], FIXED[], HOLDNG,
|
||||
KTAB[], *LINES, LINK[], LNLENG, LNPOSN,
|
||||
PARMS[], PLACE[], PTEXT[], RTEXT[], TABSIZ;
|
||||
extern signed char INLINE[LINESIZE+1], MAP1[], MAP2[];
|
||||
extern FILE *logfp;
|
||||
extern bool oldstyle;
|
||||
|
||||
struct game_t {
|
||||
/* These members are in the save order of the individual variables
|
||||
* in the 2.5 code. */
|
||||
long abbnum;
|
||||
long blklin;
|
||||
long bonus;
|
||||
long clock1;
|
||||
long clock2;
|
||||
long closed;
|
||||
long closng;
|
||||
long detail;
|
||||
long dflag;
|
||||
long dkill;
|
||||
long dtotal;
|
||||
long foobar;
|
||||
long holdng;
|
||||
long iwest;
|
||||
long knfloc;
|
||||
long limit;
|
||||
/* LL may go here */
|
||||
long lmwarn;
|
||||
/* LOC will go here */
|
||||
long newloc;
|
||||
/* OBJ will go here */
|
||||
long numdie;
|
||||
long oldlc2;
|
||||
long oldloc;
|
||||
long oldobj;
|
||||
long panic;
|
||||
long saved;
|
||||
long setup;
|
||||
long spk;
|
||||
long tally;
|
||||
long thresh;
|
||||
long trndex;
|
||||
long trnluz;
|
||||
long turns;
|
||||
/* more state will go here */
|
||||
long wzdark;
|
||||
long zzword;
|
||||
/* more state will go here */
|
||||
long clshint;
|
||||
long novice;
|
||||
/* more state will go here */
|
||||
long dseen[7];
|
||||
};
|
||||
extern struct game_t game;
|
||||
|
|
25
misc.c
25
misc.c
|
@ -2,6 +2,7 @@
|
|||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include "main.h"
|
||||
#include "share.h" /* for SETUP */
|
||||
#include "misc.h"
|
||||
#include "funcs.h"
|
||||
|
||||
|
@ -15,11 +16,11 @@ void fSPEAK(long N) {
|
|||
long BLANK, CASE, I, K, L, NEG, NPARMS, PARM, PRMTYP, STATE;
|
||||
|
||||
/* Print the message which starts at LINES(N). Precede it with a blank line
|
||||
* unless game.blklin is false. */
|
||||
* unless BLKLIN is false. */
|
||||
|
||||
|
||||
if(N == 0)return;
|
||||
BLANK=game.blklin;
|
||||
BLANK=BLKLIN;
|
||||
K=N;
|
||||
NPARMS=1;
|
||||
L10: L=IABS(LINES[K])-1;
|
||||
|
@ -182,11 +183,11 @@ long JUNK;
|
|||
* WORD2 (chars 6 thru 10 in WORD2X), else WORD2 is -1. */
|
||||
|
||||
|
||||
L10: if(game.blklin)TYPE0();
|
||||
L10: if(BLKLIN)TYPE0();
|
||||
MAPLIN(input);
|
||||
if(input == stdin && feof(stdin)) score(1);
|
||||
WORD1=GETTXT(true,true,true,0);
|
||||
if(game.blklin && WORD1 < 0) goto L10;
|
||||
if(BLKLIN && WORD1 < 0) goto L10;
|
||||
WORD1X=GETTXT(false,true,true,0);
|
||||
L12: JUNK=GETTXT(false,true,true,0);
|
||||
if(JUNK > 0) goto L12;
|
||||
|
@ -650,13 +651,13 @@ long TEMP;
|
|||
|
||||
/* Start toting an object, removing it from the list of things at its former
|
||||
* location. Incr holdng unless it was already being toted. If OBJECT>100
|
||||
* (moving "fixed" second loc), don't change PLACE or game.holdng. */
|
||||
* (moving "fixed" second loc), don't change PLACE or HOLDNG. */
|
||||
|
||||
|
||||
if(OBJECT > 100) goto L5;
|
||||
if(PLACE[OBJECT] == -1)return;
|
||||
PLACE[OBJECT]= -1;
|
||||
game.holdng=game.holdng+1;
|
||||
HOLDNG=HOLDNG+1;
|
||||
L5: if(ATLOC[WHERE] != OBJECT) goto L6;
|
||||
ATLOC[WHERE]=LINK[OBJECT];
|
||||
return;
|
||||
|
@ -676,11 +677,11 @@ void fDROP(long OBJECT, long WHERE) {
|
|||
;
|
||||
|
||||
/* Place an object at a given loc, prefixing it onto the ATLOC list. Decr
|
||||
* game.holdng if the object was being toted. */
|
||||
* HOLDNG if the object was being toted. */
|
||||
|
||||
|
||||
if(OBJECT > 100) goto L1;
|
||||
if(PLACE[OBJECT] == -1)game.holdng=game.holdng-1;
|
||||
if(PLACE[OBJECT] == -1)HOLDNG=HOLDNG-1;
|
||||
PLACE[OBJECT]=WHERE;
|
||||
goto L2;
|
||||
L1: {long x = OBJECT-100; FIXED[x]=WHERE;}
|
||||
|
@ -703,7 +704,7 @@ long ATDWRF, I;
|
|||
|
||||
|
||||
ATDWRF=0;
|
||||
if(game.dflag < 2)return(ATDWRF);
|
||||
if(DFLAG < 2)return(ATDWRF);
|
||||
ATDWRF= -1;
|
||||
for (I=1; I<=5; I++) {
|
||||
if(DLOC[I] == WHERE) goto L2;
|
||||
|
@ -885,7 +886,7 @@ long I, VAL;
|
|||
|
||||
if(MAP2[1] == 0)MPINIT();
|
||||
|
||||
if (!oldstyle && isatty(0))
|
||||
if (!oldstyle && isatty(0) && !SETUP)
|
||||
fputs("> ", stdout);
|
||||
IGNORE(fgets(INLINE+1,sizeof(INLINE)-1,OPENED));
|
||||
if (feof(OPENED)) {
|
||||
|
@ -894,10 +895,8 @@ long I, VAL;
|
|||
} else {
|
||||
if (logfp)
|
||||
IGNORE(fputs(INLINE+1, logfp));
|
||||
else if (!isatty(0)) {
|
||||
IGNORE(fputs("> ", stdout));
|
||||
else if (!isatty(0))
|
||||
IGNORE(fputs(INLINE+1, stdout));
|
||||
}
|
||||
LNLENG=0;
|
||||
for (I=1; I<=sizeof(INLINE) && INLINE[I]!=0; I++) {
|
||||
VAL=INLINE[I]+1;
|
||||
|
|
46
score.c
46
score.c
|
@ -18,7 +18,7 @@ void score(long MODE) {
|
|||
* Each treasure > chest 16 224
|
||||
* Surviving (MAX-NUM)*10 30
|
||||
* Not quitting 4 4
|
||||
* Reaching "game.closng" 25 25
|
||||
* Reaching "CLOSNG" 25 25
|
||||
* "Closed": Quit/Killed 10
|
||||
* Klutzed 25
|
||||
* Wrong way 30
|
||||
|
@ -46,26 +46,26 @@ void score(long MODE) {
|
|||
L20010: /*etc*/ ;
|
||||
} /* end loop */
|
||||
|
||||
/* Now look at how he finished and how far he got. MAXDIE and game.numdie tell us
|
||||
* how well he survived. game.dflag will
|
||||
* tell us if he ever got suitably deep into the cave. game.closng still indicates
|
||||
/* Now look at how he finished and how far he got. MAXDIE and NUMDIE tell us
|
||||
* how well he survived. 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 "game.closed"), then game.bonus is zero for mundane exits or 133, 134,
|
||||
* (indicated by "CLOSED"), then bonus is zero for mundane exits or 133, 134,
|
||||
* 135 if he blew it (so to speak). */
|
||||
|
||||
SCORE=SCORE+(MAXDIE-game.numdie)*10;
|
||||
SCORE=SCORE+(MAXDIE-NUMDIE)*10;
|
||||
MXSCOR=MXSCOR+MAXDIE*10;
|
||||
if(MODE == 0)SCORE=SCORE+4;
|
||||
MXSCOR=MXSCOR+4;
|
||||
if(game.dflag != 0)SCORE=SCORE+25;
|
||||
if(DFLAG != 0)SCORE=SCORE+25;
|
||||
MXSCOR=MXSCOR+25;
|
||||
if(game.closng)SCORE=SCORE+25;
|
||||
if(CLOSNG)SCORE=SCORE+25;
|
||||
MXSCOR=MXSCOR+25;
|
||||
if(!game.closed) goto L20020;
|
||||
if(game.bonus == 0)SCORE=SCORE+10;
|
||||
if(game.bonus == 135)SCORE=SCORE+25;
|
||||
if(game.bonus == 134)SCORE=SCORE+30;
|
||||
if(game.bonus == 133)SCORE=SCORE+45;
|
||||
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? */
|
||||
|
@ -83,9 +83,9 @@ L20020: MXSCOR=MXSCOR+45;
|
|||
for (I=1; I<=HNTMAX; I++) {
|
||||
if(HINTED[I])SCORE=SCORE-HINTS[I][2];
|
||||
} /* end loop */
|
||||
if(game.novice)SCORE=SCORE-5;
|
||||
if(game.clshint)SCORE=SCORE-10;
|
||||
SCORE=SCORE-game.trnluz-game.saved;
|
||||
if(NOVICE)SCORE=SCORE-5;
|
||||
if(CLSHNT)SCORE=SCORE-10;
|
||||
SCORE=SCORE-TRNLUZ-SAVED;
|
||||
|
||||
/* Return to score command if that's where we came from. */
|
||||
|
||||
|
@ -93,25 +93,25 @@ L20020: MXSCOR=MXSCOR+45;
|
|||
|
||||
/* that should be good enough. Let's tell him all about it. */
|
||||
|
||||
if(SCORE+game.trnluz+1 >= MXSCOR && game.trnluz != 0)RSPEAK(242);
|
||||
if(SCORE+game.saved+1 >= MXSCOR && game.saved != 0)RSPEAK(143);
|
||||
if(SCORE+TRNLUZ+1 >= MXSCOR && TRNLUZ != 0)RSPEAK(242);
|
||||
if(SCORE+SAVED+1 >= MXSCOR && SAVED != 0)RSPEAK(143);
|
||||
SETPRM(1,SCORE,MXSCOR);
|
||||
SETPRM(3,game.turns,game.turns);
|
||||
SETPRM(3,TURNS,TURNS);
|
||||
RSPEAK(262);
|
||||
for (I=1; I<=CLSSES; I++) {
|
||||
if(CVAL[I] >= SCORE) goto L20210;
|
||||
/*etc*/ ;
|
||||
} /* end loop */
|
||||
game.spk=265;
|
||||
SPK=265;
|
||||
goto L25000;
|
||||
|
||||
L20210: SPEAK(CTEXT[I]);
|
||||
game.spk=264;
|
||||
SPK=264;
|
||||
if(I >= CLSSES) goto L25000;
|
||||
I=CVAL[I]+1-SCORE;
|
||||
SETPRM(1,I,I);
|
||||
game.spk=263;
|
||||
L25000: RSPEAK(game.spk);
|
||||
SPK=263;
|
||||
L25000: RSPEAK(SPK);
|
||||
exit(0);
|
||||
|
||||
}
|
||||
|
|
37
share.h
37
share.h
|
@ -1,21 +1,24 @@
|
|||
extern void score(long);
|
||||
extern long ACTSPK[], AMBER, ATTACK, AXE, BACK, BATTER, BEAR,
|
||||
BIRD, BLOOD,
|
||||
extern long ABBNUM, ACTSPK[], AMBER, ATTACK, AXE, BACK, BATTER, BEAR,
|
||||
BIRD, BLOOD, BONUS,
|
||||
BOTTLE, CAGE, CAVE, CAVITY, CHAIN, CHASM, CHEST, CHLOC, CHLOC2,
|
||||
CLAM, CLSMAX, CLSSES, COINS, COND[], CONDS, CTEXT[], CVAL[], DALTLC,
|
||||
DOOR, DPRSSN, DRAGON, DWARF, EGGS,
|
||||
EMRALD, ENTER, ENTRNC, FIND, FISSUR, FIXD[], FOOD,
|
||||
CLAM, CLOCK1, CLOCK2, CLOSED, CLOSNG, CLSHNT, CLSMAX, CLSSES,
|
||||
COINS, COND[], CONDS, CTEXT[], CVAL[], DALTLC, DETAIL,
|
||||
DKILL, DOOR, DPRSSN, DRAGON, DSEEN[], DTOTAL, DWARF, EGGS,
|
||||
EMRALD, ENTER, ENTRNC, FIND, FISSUR, FIXD[], FOOBAR, FOOD,
|
||||
GRATE, HINT, HINTED[], HINTLC[], HINTS[][5], HNTMAX,
|
||||
HNTSIZ, I, INVENT, IGO, J, JADE, K, K2, KEY[], KEYS, KK,
|
||||
KNIFE, KQ, L, LAMP, LINSIZ, LINUSE, LL,
|
||||
LOC, LOCK, LOCSIZ, LOCSND[], LOOK, LTEXT[],
|
||||
HNTSIZ, I, INVENT, IGO, IWEST, J, JADE, K, K2, KEY[], KEYS, KK,
|
||||
KNFLOC, KNIFE, KQ, L, LAMP, LIMIT, LINSIZ, LINUSE, LL,
|
||||
LMWARN, LOC, LOCK, LOCSIZ, LOCSND[], LOOK, LTEXT[],
|
||||
MAGZIN, MAXDIE, MAXTRS, MESH, MESSAG, MIRROR, MXSCOR,
|
||||
NUGGET, NUL, OBJ, OBJSND[],
|
||||
OBJTXT[], ODLOC[], OGRE, OIL, OYSTER,
|
||||
PEARL, PILLOW, PLAC[], PLANT, PLANT2, PROP[], PYRAM,
|
||||
RESER, ROD, ROD2, RTXSIZ, RUBY, RUG, SAPPH, SAY,
|
||||
SCORE, SECT, SIGN, SNAKE, STEPS, STEXT[], STICK,
|
||||
STREAM, TABNDX, THROW, TK[], TRAVEL[], TRIDNT,
|
||||
TRNSIZ, TRNVAL[], TRNVLS, TROLL, TROLL2, TRVS,
|
||||
TRVSIZ, TTEXT[], URN, V1, V2, VASE, VEND, VERB,
|
||||
VOLCAN, VRBSIZ, VRSION, WATER, WD1, WD1X, WD2, WD2X;
|
||||
NEWLOC, NOVICE, NUGGET, NUL, NUMDIE, OBJ, OBJSND[],
|
||||
OBJTXT[], ODLOC[], OGRE, OIL, OLDLC2, OLDLOC, OLDOBJ, OYSTER,
|
||||
PANIC, PEARL, PILLOW, PLAC[], PLANT, PLANT2, PROP[], PYRAM,
|
||||
RESER, ROD, ROD2, RTXSIZ, RUBY, RUG, SAPPH, SAVED, SAY,
|
||||
SCORE, SECT, SETUP, SIGN, SNAKE, SPK, STEPS, STEXT[], STICK,
|
||||
STREAM, TABNDX, TALLY, THRESH, THROW, TK[], TRAVEL[], TRIDNT,
|
||||
TRNDEX, TRNLUZ, TRNSIZ, TRNVAL[], TRNVLS, TROLL, TROLL2, TRVS,
|
||||
TRVSIZ, TTEXT[], TURNS, URN, V1, V2, VASE, VEND, VERB,
|
||||
VOLCAN, VRBSIZ, VRSION, WATER, WD1, WD1X, WD2, WD2X,
|
||||
WZDARK, ZZWORD;
|
||||
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue