X-Git-Url: https://jxself.org/git/?a=blobdiff_plain;f=main.c;h=fd0852f696172871a8ddd19e19a84cd8fdd43b2f;hb=c11938aed5e261ac40a562781325996628663610;hp=027f92d46ba00fa5bd4c4541ca52737944dbcdbd;hpb=08f77c692a84d836e494c8cd469f5ac00524cf1c;p=open-adventure.git diff --git a/main.c b/main.c index 027f92d..fd0852f 100644 --- a/main.c +++ b/main.c @@ -1,20 +1,6 @@ /* - * There used to be a note that said this: - * - * The author - Don Woods - apologises for the style of the code; it - * is a result of running the original Fortran IV source through a - * home-brew Fortran-to-C converter. - * - * Now that the code has been restructured into something much closer - * to idiomatic C, the following is more appropriate: - * - * ESR apologizes for the remaing gotos (now confined to one function - * in this file - there used to be over 350 of them, *everywhere*). - * Applying the Structured Program Theorem can be hard. - * - * Copyright (c) 1977, 2005 by Will Crowther and Don Woods - * Copyright (c) 2017 by Eric S. Raymond - * SPDX-License-Identifier: BSD-2-clause + * SPDX-FileCopyrightText: (C) 1977, 2005 by Will Crowther and Don Woods + * SPDX-License-Identifier: BSD-2-Clause */ #include @@ -24,11 +10,24 @@ #include #include #include +#include +#include #include "advent.h" -#include "dungeon.h" #define DIM(a) (sizeof(a)/sizeof(a[0])) +#if defined ADVENT_AUTOSAVE +static FILE* autosave_fp; +void autosave(void) +{ + if (autosave_fp != NULL) { + rewind(autosave_fp); + savefile(autosave_fp); + fflush(autosave_fp); + } +} +#endif + // LCOV_EXCL_START // exclude from coverage analysis because it requires interactivity to test static void sig_handler(int signo) @@ -37,190 +36,165 @@ static void sig_handler(int signo) if (settings.logfp != NULL) fflush(settings.logfp); } + +#if defined ADVENT_AUTOSAVE + if (signo == SIGHUP || signo == SIGTERM) { + autosave(); + } +#endif exit(EXIT_FAILURE); } // LCOV_EXCL_STOP -/* - * MAIN PROGRAM - * - * Adventure (rev 2: 20 treasures) - * History: Original idea & 5-treasure version (adventures) by Willie Crowther - * 15-treasure version (adventure) by Don Woods, April-June 1977 - * 20-treasure version (rev 2) by Don Woods, August 1978 - * Errata fixed: 78/12/25 - * Revived 2017 as Open Adventure. - */ - -static bool do_command(void); - -int main(int argc, char *argv[]) +char *myreadline(const char *prompt) { - int ch; - - /* Options. */ - -#ifndef ADVENT_NOSAVE - const char* opts = "l:or:"; - const char* usage = "Usage: %s [-l logfilename] [-o] [-r restorefilename]\n"; - FILE *rfp = NULL; -#else - const char* opts = "l:o"; - const char* usage = "Usage: %s [-l logfilename] [-o]\n"; -#endif - while ((ch = getopt(argc, argv, opts)) != EOF) { - switch (ch) { - case 'l': - settings.logfp = fopen(optarg, "w"); - if (settings.logfp == NULL) - fprintf(stderr, - "advent: can't open logfile %s for write\n", - optarg); - signal(SIGINT, sig_handler); - break; - case 'o': - settings.oldstyle = true; - settings.prompt = false; - break; -#ifndef ADVENT_NOSAVE - case 'r': - rfp = fopen(optarg, "r"); - if (rfp == NULL) - fprintf(stderr, - "advent: can't open save file %s for read\n", - optarg); - break; -#endif - default: - fprintf(stderr, - usage, argv[0]); - fprintf(stderr, - " -l create a log file of your game named as specified'\n"); - fprintf(stderr, - " -o 'oldstyle' (no prompt, no command editing, displays 'Initialising...')\n"); -#ifndef ADVENT_NOSAVE - fprintf(stderr, - " -r restore from specified saved game file\n"); -#endif - exit(EXIT_FAILURE); - break; - } + /* + * This function isn't required for gameplay, readline() straight + * up would suffice for that. It's where we interpret command-line + * logfiles for testing purposes. + */ + /* Normal case - no script arguments */ + if (settings.argc == 0) { + char *ln = readline(prompt); + if (ln == NULL) { + fputs(prompt, stdout); + } + return ln; } - /* Initialize game variables */ - long seedval = initialise(); + char *buf = malloc(LINESIZE + 1); + for (;;) { + if (settings.scriptfp == NULL || feof(settings.scriptfp)) { + if (settings.optind >= settings.argc) { + free(buf); + return NULL; + } -#ifndef ADVENT_NOSAVE - if (!rfp) { - game.novice = yes(arbitrary_messages[WELCOME_YOU], arbitrary_messages[CAVE_NEARBY], arbitrary_messages[NO_MESSAGE]); - if (game.novice) - game.limit = NOVICELIMIT; - } else { - restore(rfp); - } -#else - game.novice = yes(arbitrary_messages[WELCOME_YOU], arbitrary_messages[CAVE_NEARBY], arbitrary_messages[NO_MESSAGE]); - if (game.novice) - game.limit = NOVICELIMIT; -#endif + char *next = settings.argv[settings.optind++]; - if (settings.logfp) - fprintf(settings.logfp, "seed %ld\n", seedval); + if (settings.scriptfp != NULL && feof(settings.scriptfp)) { + fclose(settings.scriptfp); + } + if (strcmp(next, "-") == 0) { + settings.scriptfp = stdin; // LCOV_EXCL_LINE + } else { + settings.scriptfp = fopen(next, "r"); + } + } - /* interpret commands until EOF or interrupt */ - for (;;) { - if (!do_command()) - break; + if (isatty(fileno(settings.scriptfp))) { + free(buf); // LCOV_EXCL_LINE + return readline(prompt); // LCOV_EXCL_LINE + } else { + char *ln = fgets(buf, LINESIZE, settings.scriptfp); + if (ln != NULL) { + fputs(prompt, stdout); + fputs(ln, stdout); + return ln; + } + } } - /* show score and exit */ - terminate(quitgame); + + return NULL; } -/* Check if this loc is eligible for any hints. If been here long +/* Check if this loc is eligible for any hints. If been here int * enough, display. Ignore "HINTS" < 4 (special stuff, see database * notes). */ static void checkhints(void) { if (conditions[game.loc] >= game.conds) { for (int hint = 0; hint < NHINTS; hint++) { - if (game.hinted[hint]) - continue; - if (!CNDBIT(game.loc, hint + 1 + COND_HBASE)) - game.hintlc[hint] = -1; - ++game.hintlc[hint]; - /* Come here if he's been long enough at required loc(s) for some + if (game.hints[hint].used) { + continue; + } + if (!CNDBIT(game.loc, hint + 1 + COND_HBASE)) { + game.hints[hint].lc = -1; + } + ++game.hints[hint].lc; + /* Come here if he's been int enough at required loc(s) for some * unused hint. */ - if (game.hintlc[hint] >= hints[hint].turns) { + if (game.hints[hint].lc >= hints[hint].turns) { int i; switch (hint) { case 0: /* cave */ - if (game.prop[GRATE] == GRATE_CLOSED && !HERE(KEYS)) - break; - game.hintlc[hint] = 0; + if (game.objects[GRATE].prop == GRATE_CLOSED && !HERE(KEYS)) { + break; + } + game.hints[hint].lc = 0; return; case 1: /* bird */ - if (game.place[BIRD] == game.loc && TOTING(ROD) && game.oldobj == BIRD) - break; + if (game.objects[BIRD].place == game.loc && TOTING(ROD) && game.oldobj == BIRD) { + break; + } return; case 2: /* snake */ - if (HERE(SNAKE) && !HERE(BIRD)) - break; - game.hintlc[hint] = 0; + if (HERE(SNAKE) && !HERE(BIRD)) { + break; + } + game.hints[hint].lc = 0; return; case 3: /* maze */ - if (game.atloc[game.loc] == NO_OBJECT && - game.atloc[game.oldloc] == NO_OBJECT && - game.atloc[game.oldlc2] == NO_OBJECT && + if (game.locs[game.loc].atloc == NO_OBJECT && + game.locs[game.oldloc].atloc == NO_OBJECT && + game.locs[game.oldlc2].atloc == NO_OBJECT && game.holdng > 1) break; - game.hintlc[hint] = 0; + game.hints[hint].lc = 0; return; case 4: /* dark */ - if (game.prop[EMERALD] != STATE_NOTFOUND && game.prop[PYRAMID] == STATE_NOTFOUND) - break; - game.hintlc[hint] = 0; + if (!PROP_IS_NOTFOUND(EMERALD) && PROP_IS_NOTFOUND(PYRAMID)) { + break; + } + game.hints[hint].lc = 0; return; case 5: /* witt */ break; case 6: /* urn */ - if (game.dflag == 0) - break; - game.hintlc[hint] = 0; + if (game.dflag == 0) { + break; + } + game.hints[hint].lc = 0; return; case 7: /* woods */ - if (game.atloc[game.loc] == NO_OBJECT && - game.atloc[game.oldloc] == NO_OBJECT && - game.atloc[game.oldlc2] == NO_OBJECT) + if (game.locs[game.loc].atloc == NO_OBJECT && + game.locs[game.oldloc].atloc == NO_OBJECT && + game.locs[game.oldlc2].atloc == NO_OBJECT) break; return; case 8: /* ogre */ i = atdwrf(game.loc); if (i < 0) { - game.hintlc[hint] = 0; + game.hints[hint].lc = 0; return; } - if (HERE(OGRE) && i == 0) + if (HERE(OGRE) && i == 0) { break; + } return; case 9: /* jade */ - if (game.tally == 1 && game.prop[JADE] < 0) - break; - game.hintlc[hint] = 0; + if (game.tally == 1 && PROP_IS_STASHED_OR_UNSEEN(JADE)) { + break; + } + game.hints[hint].lc = 0; return; default: // LCOV_EXCL_LINE + // Should never happen BUG(HINT_NUMBER_EXCEEDS_GOTO_LIST); // LCOV_EXCL_LINE } /* Fall through to hint display */ - game.hintlc[hint] = 0; - if (!yes(hints[hint].question, arbitrary_messages[NO_MESSAGE], arbitrary_messages[OK_MAN])) + game.hints[hint].lc = 0; + if (!yes_or_no(hints[hint].question, arbitrary_messages[NO_MESSAGE], arbitrary_messages[OK_MAN])) { return; + } rspeak(HINT_COST, hints[hint].penalty, hints[hint].penalty); - game.hinted[hint] = yes(arbitrary_messages[WANT_HINT], hints[hint].hint, arbitrary_messages[OK_MAN]); - if (game.hinted[hint] && game.limit > WARNTIME) + game.hints[hint].used = yes_or_no(arbitrary_messages[WANT_HINT], hints[hint].hint, arbitrary_messages[OK_MAN]); + if (game.hints[hint].used && game.limit > WARNTIME) { game.limit += WARNTIME * hints[hint].penalty; + } } } } @@ -228,39 +202,41 @@ static void checkhints(void) static bool spotted_by_pirate(int i) { - if (i != PIRATE) - return false; + if (i != PIRATE) { + return false; + } /* The pirate's spotted him. Pirate leaves him alone once we've * found chest. K counts if a treasure is here. If not, and * tally=1 for an unseen chest, let the pirate be spotted. Note - * that game.place[CHEST] = LOC_NOWHERE might mean that he's thrown + * that game.objexts,place[CHEST] = LOC_NOWHERE might mean that he's thrown * it to the troll, but in that case he's seen the chest - * (game.prop[CHEST] == STATE_FOUND). */ - if (game.loc == game.chloc || - game.prop[CHEST] != STATE_NOTFOUND) + * PROP_IS_FOUND(CHEST) == true. */ + if (game.loc == game.chloc || !PROP_IS_NOTFOUND(CHEST)) { return true; + } int snarfed = 0; bool movechest = false, robplayer = false; for (int treasure = 1; treasure <= NOBJECTS; treasure++) { - if (!objects[treasure].is_treasure) + if (!objects[treasure].is_treasure) { continue; + } /* Pirate won't take pyramid from plover room or dark * room (too easy!). */ if (treasure == PYRAMID && (game.loc == objects[PYRAMID].plac || game.loc == objects[EMERALD].plac)) { continue; } - if (TOTING(treasure) || - HERE(treasure)) + if (TOTING(treasure) || HERE(treasure)) { ++snarfed; + } if (TOTING(treasure)) { movechest = true; robplayer = true; } } /* Force chest placement before player finds last treasure */ - if (game.tally == 1 && snarfed == 0 && game.place[CHEST] == LOC_NOWHERE && HERE(LAMP) && game.prop[LAMP] == LAMP_BRIGHT) { + if (game.tally == 1 && snarfed == 0 && game.objects[CHEST].place == LOC_NOWHERE && HERE(LAMP) && game.objects[LAMP].prop == LAMP_BRIGHT) { rspeak(PIRATE_SPOTTED); movechest = true; } @@ -269,26 +245,30 @@ static bool spotted_by_pirate(int i) if (movechest) { move(CHEST, game.chloc); move(MESSAG, game.chloc2); - game.dloc[PIRATE] = game.chloc; - game.odloc[PIRATE] = game.chloc; - game.dseen[PIRATE] = false; + game.dwarves[PIRATE].loc = game.chloc; + game.dwarves[PIRATE].oldloc = game.chloc; + game.dwarves[PIRATE].seen = false; } else { /* You might get a hint of the pirate's presence even if the * chest doesn't move... */ - if (game.odloc[PIRATE] != game.dloc[PIRATE] && PCT(20)) - rspeak(PIRATE_RUSTLES); + if (game.dwarves[PIRATE].oldloc != game.dwarves[PIRATE].loc && PCT(20)) { + rspeak(PIRATE_RUSTLES); + } } if (robplayer) { rspeak(PIRATE_POUNCES); for (int treasure = 1; treasure <= NOBJECTS; treasure++) { - if (!objects[treasure].is_treasure) - continue; + if (!objects[treasure].is_treasure) { + continue; + } if (!(treasure == PYRAMID && (game.loc == objects[PYRAMID].plac || game.loc == objects[EMERALD].plac))) { - if (AT(treasure) && game.fixed[treasure] == IS_FREE) - carry(treasure, game.loc); - if (TOTING(treasure)) - drop(treasure, game.chloc); + if (AT(treasure) && game.objects[treasure].fixed == IS_FREE) { + carry(treasure, game.loc); + } + if (TOTING(treasure)) { + drop(treasure, game.chloc); + } } } } @@ -296,9 +276,8 @@ static bool spotted_by_pirate(int i) return true; } -static bool dwarfmove(void) +static bool dwarfmove(void) { /* Dwarves move. Return true if player survives, false if he dies. */ -{ int kk, stick, attack; loc_t tk[21]; @@ -314,10 +293,9 @@ static bool dwarfmove(void) * 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 (game.loc == LOC_NOWHERE || - FORCED(game.loc) || - CNDBIT(game.newloc, COND_NOARRR)) + if (game.loc == LOC_NOWHERE || FORCED(game.loc) || CNDBIT(game.newloc, COND_NOARRR)) { return true; + } /* Dwarf activity level ratchets up */ if (game.dflag == 0) { @@ -331,22 +309,24 @@ static bool dwarfmove(void) * replace him with the alternate. */ if (game.dflag == 1) { if (!INDEEP(game.loc) || - (PCT(95) && (!CNDBIT(game.loc, COND_NOBACK) || - PCT(85)))) + (PCT(95) && (!CNDBIT(game.loc, COND_NOBACK) || PCT(85)))) { return true; + } game.dflag = 2; for (int i = 1; i <= 2; i++) { int j = 1 + randrange(NDWARVES - 1); - if (PCT(50)) - game.dloc[j] = 0; + if (PCT(50)) { + game.dwarves[j].loc = 0; + } } /* Alternate initial loc for dwarf, in case one of them * starts out on top of the adventurer. */ for (int i = 1; i <= NDWARVES - 1; i++) { - if (game.dloc[i] == game.loc) - game.dloc[i] = DALTLC; // - game.odloc[i] = game.dloc[i]; + if (game.dwarves[i].loc == game.loc) { + game.dwarves[i].loc = DALTLC; + } + game.dwarves[i].oldloc = game.dwarves[i].loc; } rspeak(DWARF_RAN); drop(AXE, game.loc); @@ -363,11 +343,12 @@ static bool dwarfmove(void) attack = 0; stick = 0; for (int i = 1; i <= NDWARVES; i++) { - if (game.dloc[i] == 0) - continue; + if (game.dwarves[i].loc == 0) { + continue; + } /* Fill tk array with all the places this dwarf might go. */ unsigned int j = 1; - kk = tkey[game.dloc[i]]; + kk = tkey[game.dwarves[i].loc]; if (kk != 0) do { enum desttype_t desttype = travel[kk].desttype; @@ -377,14 +358,14 @@ static bool dwarfmove(void) continue; else if (!INDEEP(game.newloc)) continue; - else if (game.newloc == game.odloc[i]) + else if (game.newloc == game.dwarves[i].oldloc) continue; else if (j > 1 && game.newloc == tk[j - 1]) continue; else if (j >= DIM(tk) - 1) /* This can't actually happen. */ continue; // LCOV_EXCL_LINE - else if (game.newloc == game.dloc[i]) + else if (game.newloc == game.dwarves[i].loc) continue; else if (FORCED(game.newloc)) continue; @@ -395,39 +376,47 @@ static bool dwarfmove(void) tk[j++] = game.newloc; } while (!travel[kk++].stop); - tk[j] = game.odloc[i]; - if (j >= 2) + tk[j] = game.dwarves[i].oldloc; + if (j >= 2) { --j; + } j = 1 + randrange(j); - game.odloc[i] = game.dloc[i]; - game.dloc[i] = tk[j]; - game.dseen[i] = (game.dseen[i] && INDEEP(game.loc)) || - (game.dloc[i] == game.loc || - game.odloc[i] == game.loc); - if (!game.dseen[i]) + game.dwarves[i].oldloc = game.dwarves[i].loc; + game.dwarves[i].loc = tk[j]; + game.dwarves[i].seen = (game.dwarves[i].seen && INDEEP(game.loc)) || + (game.dwarves[i].loc == game.loc || + game.dwarves[i].oldloc == game.loc); + if (!game.dwarves[i].seen) { continue; - game.dloc[i] = game.loc; - if (spotted_by_pirate(i)) + } + game.dwarves[i].loc = game.loc; + if (spotted_by_pirate(i)) { continue; + } /* This threatening little dwarf is in the room with him! */ ++game.dtotal; - if (game.odloc[i] == game.dloc[i]) { + if (game.dwarves[i].oldloc == game.dwarves[i].loc) { ++attack; - if (game.knfloc >= 0) + if (game.knfloc >= LOC_NOWHERE) { game.knfloc = game.loc; - if (randrange(1000) < 95 * (game.dflag - 2)) + } + if (randrange(1000) < 95 * (game.dflag - 2)) { ++stick; + } } } /* Now we know what's happening. Let's tell the poor sucker about it. */ - if (game.dtotal == 0) + if (game.dtotal == 0) { return true; + } rspeak(game.dtotal == 1 ? DWARF_SINGLE : DWARF_PACK, game.dtotal); - if (attack == 0) + if (attack == 0) { return true; - if (game.dflag == 2) + } + if (game.dflag == 2) { game.dflag = 3; + } if (attack > 1) { rspeak(THROWN_KNIVES, attack); rspeak(stick > 1 ? MULTIPLE_HITS : (stick == 1 ? ONE_HIT : NONE_HIT), stick); @@ -435,8 +424,9 @@ static bool dwarfmove(void) rspeak(KNIFE_THROWN); rspeak(stick ? GETS_YOU : MISSES_YOU); } - if (stick == 0) + if (stick == 0) { return true; + } game.oldlc2 = game.loc; return false; } @@ -460,27 +450,30 @@ static bool dwarfmove(void) * 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". */ - -static void croak(void) +static void croak(void) { /* Okay, he's dead. Let's get on with it. */ -{ - if (game.numdie < 0) - game.numdie = 0; // LCOV_EXCL_LINE const char* query = obituaries[game.numdie].query; const char* yes_response = obituaries[game.numdie].yes_response; + ++game.numdie; + if (game.closng) { /* He died during closing time. No resurrection. Tally up a * death and exit. */ rspeak(DEATH_CLOSING); terminate(endgame); - } else if ( !yes(query, yes_response, arbitrary_messages[OK_MAN]) - || game.numdie == NDEATHS) + } else if (!yes_or_no(query, yes_response, arbitrary_messages[OK_MAN]) + || game.numdie == NDEATHS) { + /* Player is asked if he wants to try again. If not, or if + * he's already used all of his lives, we end the game */ terminate(endgame); - else { - game.place[WATER] = game.place[OIL] = LOC_NOWHERE; + } else { + /* If player wishes to continue, we empty the liquids in the + * user's inventory, turn off the lamp, and drop all items + * where he died. */ + game.objects[WATER].place = game.objects[OIL].place = LOC_NOWHERE; if (TOTING(LAMP)) - game.prop[LAMP] = LAMP_DARK; + game.objects[LAMP].prop = LAMP_DARK; for (int j = 1; j <= NOBJECTS; j++) { int i = NOBJECTS + 1 - j; if (TOTING(i)) { @@ -492,9 +485,30 @@ static void croak(void) } } -static bool traveleq(int a, int b) +static void describe_location(void) { +/* Describe the location to the user */ + const char* msg = locations[game.loc].description.small; + + if (MOD(game.locs[game.loc].abbrev, game.abbnum) == 0 || msg == NO_MESSAGE) + msg = locations[game.loc].description.big; + + if (!FORCED(game.loc) && DARK(game.loc)) { + msg = arbitrary_messages[PITCH_DARK]; + } + + if (TOTING(BEAR)) { + rspeak(TAME_BEAR); + } + + speak(msg); + + if (game.loc == LOC_Y2 && PCT(25) && !game.closng) + rspeak(SAYS_PLUGH); +} + + +static bool traveleq(int a, int b) { /* Are two travel entries equal for purposes of skip after failed condition? */ -{ return (travel[a].condtype == travel[b].condtype) && (travel[a].condarg1 == travel[b].condarg1) && (travel[a].condarg2 == travel[b].condarg2) @@ -509,16 +523,16 @@ static bool traveleq(int a, int b) * 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.) */ - -static void playermove( int motion) +static void playermove(int motion) { int scratchloc, travel_entry = tkey[game.loc]; game.newloc = game.loc; - if (travel_entry == 0) + if (travel_entry == 0) { BUG(LOCATION_HAS_NO_TRAVEL_ENTRIES); // LCOV_EXCL_LINE - if (motion == NUL) + } + if (motion == NUL) { return; - else if (motion == BACK) { + } else if (motion == BACK) { /* Handle "go back". Look for verb which goes from game.loc to * game.oldloc, or to game.oldlc2 If game.oldloc has forced-motion. * te_tmp saves entry -> forced loc -> previous loc. */ @@ -565,11 +579,12 @@ static void playermove( int motion) /* 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. */ - if (game.detail < 3) - rspeak(NO_MORE_DETAIL); + if (game.detail < 3) { + rspeak(NO_MORE_DETAIL); + } ++game.detail; game.wzdark = false; - game.abbrev[game.loc] = 0; + game.locs[game.loc].abbrev = 0; return; } else if (motion == CAVE) { /* Cave. Different messages depending on whether above ground. */ @@ -584,8 +599,7 @@ static void playermove( int motion) /* Look for a way to fulfil the motion verb passed in - travel_entry indexes * the beginning of the motion entries for here (game.loc). */ for (;;) { - if (T_TERMINATE(travel[travel_entry]) || - travel[travel_entry].motion == motion) + if ((travel[travel_entry].motion == HERE) || travel[travel_entry].motion == motion) break; if (travel[travel_entry].stop) { /* Couldn't find an entry matching the motion word passed @@ -634,23 +648,22 @@ static void playermove( int motion) for (;;) { /* L12 loop */ for (;;) { enum condtype_t condtype = travel[travel_entry].condtype; - long condarg1 = travel[travel_entry].condarg1; - long condarg2 = travel[travel_entry].condarg2; + int condarg1 = travel[travel_entry].condarg1; + int condarg2 = travel[travel_entry].condarg2; if (condtype < cond_not) { /* YAML N and [pct N] conditionals */ if (condtype == cond_goto || condtype == cond_pct) { - if (condarg1 == 0 || - PCT(condarg1)) + if (condarg1 == 0 || PCT(condarg1)) break; /* else fall through */ } /* YAML [with OBJ] clause */ - else if (TOTING(condarg1) || - (condtype == cond_with && AT(condarg1))) + else if (TOTING(condarg1) || (condtype == cond_with && AT(condarg1))) break; /* else fall through to check [not OBJ STATE] */ - } else if (game.prop[condarg1] != condarg2) + } else if (game.objects[condarg1].prop != condarg2) { break; + } /* We arrive here on conditional failure. * Skip to next non-matching destination */ @@ -667,8 +680,9 @@ static void playermove( int motion) /* Found an eligible rule, now execute it */ enum desttype_t desttype = travel[travel_entry].desttype; game.newloc = travel[travel_entry].destval; - if (desttype == dest_goto) + if (desttype == dest_goto) { return; + } if (desttype == dest_speak) { /* Execute a speak rule */ @@ -685,8 +699,7 @@ static void playermove( int motion) game.newloc = (game.loc == LOC_PLOVER) ? LOC_ALCOVE : LOC_PLOVER; - if (game.holdng > 1 || - (game.holdng == 1 && !TOTING(EMERALD))) { + if (game.holdng > 1 || (game.holdng == 1 && !TOTING(EMERALD))) { game.newloc = game.loc; rspeak(MUST_DROP); } @@ -720,10 +733,10 @@ static void playermove( int motion) * (standard travel entries check for * game.prop[TROLL]=TROLL_UNPAID.) Special stuff * for bear. */ - if (game.prop[TROLL] == TROLL_PAIDONCE) { - pspeak(TROLL, look, TROLL_PAIDONCE, true); - game.prop[TROLL] = TROLL_UNPAID; - move(TROLL2, LOC_NOWHERE); + if (game.objects[TROLL].prop == TROLL_PAIDONCE) { + pspeak(TROLL, look, true, TROLL_PAIDONCE); + game.objects[TROLL].prop = TROLL_UNPAID; + DESTROY(TROLL2); move(TROLL2 + NOBJECTS, IS_FREE); move(TROLL, objects[TROLL].plac); move(TROLL + NOBJECTS, objects[TROLL].fixd); @@ -732,15 +745,16 @@ static void playermove( int motion) return; } else { game.newloc = objects[TROLL].plac + objects[TROLL].fixd - game.loc; - if (game.prop[TROLL] == TROLL_UNPAID) - game.prop[TROLL] = TROLL_PAIDONCE; - if (!TOTING(BEAR)) + if (game.objects[TROLL].prop == TROLL_UNPAID) + game.objects[TROLL].prop = TROLL_PAIDONCE; + if (!TOTING(BEAR)) { return; + } state_change(CHASM, BRIDGE_WRECKED); - game.prop[TROLL] = TROLL_GONE; + game.objects[TROLL].prop = TROLL_GONE; drop(BEAR, game.newloc); - game.fixed[BEAR] = IS_FIXED; - game.prop[BEAR] = BEAR_DEAD; + game.objects[BEAR].fixed = IS_FIXED; + game.objects[BEAR].prop = BEAR_DEAD; game.oldlc2 = game.newloc; croak(); return; @@ -755,26 +769,72 @@ static void playermove( int motion) (false); } -static bool closecheck(void) +static void lampcheck(void) { +/* Check game limit and lamp timers */ + if (game.objects[LAMP].prop == LAMP_BRIGHT) { + --game.limit; + } + + /* 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. + * First following arm checks if the lamp and fresh batteries are + * here, in which case we replace the batteries and continue. + * Second is for other cases of lamp dying. Even after it goes + * out, he can explore outside for a while if desired. */ + if (game.limit <= WARNTIME) { + if (HERE(BATTERY) && game.objects[BATTERY].prop == FRESH_BATTERIES && HERE(LAMP)) { + rspeak(REPLACE_BATTERIES); + game.objects[BATTERY].prop = DEAD_BATTERIES; +#ifdef __unused__ + /* This code from the original game seems to have been faulty. + * No tests ever passed the guard, and with the guard removed + * the game hangs when the lamp limit is reached. + */ + if (TOTING(BATTERY)) { + drop(BATTERY, game.loc); + } +#endif + game.limit += BATTERYLIFE; + game.lmwarn = false; + } else if (!game.lmwarn && HERE(LAMP)) { + game.lmwarn = true; + if (game.objects[BATTERY].prop == DEAD_BATTERIES) { + rspeak(MISSING_BATTERIES); + } else if (game.objects[BATTERY].place == LOC_NOWHERE) { + rspeak(LAMP_DIM); + } else { + rspeak(GET_BATTERIES); + } + } + } + if (game.limit == 0) { + game.limit = -1; + game.objects[LAMP].prop = LAMP_DARK; + if (HERE(LAMP)) { + rspeak(LAMP_OUT); + } + } +} + /* 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 - * 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. */ -{ + * while inside the cave). When it hits zero, we 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 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. */ +static bool closecheck(void) { /* If a turn threshold has been met, apply penalties and tell * the player about it. */ for (int i = 0; i < NTHRESHOLDS; ++i) { @@ -785,8 +845,9 @@ static bool closecheck(void) } /* Don't tick game.clock1 unless well into cave (and not at Y2). */ - if (game.tally == 0 && INDEEP(game.loc) && game.loc != LOC_Y2) + if (game.tally == 0 && INDEEP(game.loc) && game.loc != LOC_Y2) { --game.clock1; + } /* When the first warning comes, we lock the grate, destroy * the bridge, kill all the dwarves (and the pirate), remove @@ -802,27 +863,28 @@ static bool closecheck(void) * know the bivalve is an oyster. *And*, the dwarves must * have been activated, since we've found chest. */ if (game.clock1 == 0) { - game.prop[GRATE] = GRATE_CLOSED; - game.prop[FISSURE] = UNBRIDGED; + game.objects[GRATE].prop = GRATE_CLOSED; + game.objects[FISSURE].prop = UNBRIDGED; for (int i = 1; i <= NDWARVES; i++) { - game.dseen[i] = false; - game.dloc[i] = LOC_NOWHERE; + game.dwarves[i].seen = false; + game.dwarves[i].loc = LOC_NOWHERE; } - move(TROLL, LOC_NOWHERE); + DESTROY(TROLL); move(TROLL + NOBJECTS, IS_FREE); move(TROLL2, objects[TROLL].plac); move(TROLL2 + NOBJECTS, objects[TROLL].fixd); juggle(CHASM); - if (game.prop[BEAR] != BEAR_DEAD) + if (game.objects[BEAR].prop != BEAR_DEAD) { DESTROY(BEAR); - game.prop[CHAIN] = CHAIN_HEAP; - game.fixed[CHAIN] = IS_FREE; - game.prop[AXE] = AXE_HERE; - game.fixed[AXE] = IS_FREE; + } + game.objects[CHAIN].prop = CHAIN_HEAP; + game.objects[CHAIN].fixed = IS_FREE; + game.objects[AXE].prop = AXE_HERE; + game.objects[AXE].fixed = IS_FREE; rspeak(CAVE_CLOSING); game.clock1 = -1; game.closng = true; - return true; + return game.closed; } else if (game.clock1 < 0) --game.clock2; if (game.clock2 == 0) { @@ -837,91 +899,49 @@ static bool closecheck(void) * 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 + * objects be handled differently. We also drop all other + * objects he might be carrying (lest he has some which * could cause trouble, such as the keys). We describe the * flash of light and trundle back. */ - game.prop[BOTTLE] = put(BOTTLE, LOC_NE, EMPTY_BOTTLE); - game.prop[PLANT] = put(PLANT, LOC_NE, PLANT_THIRSTY); - game.prop[OYSTER] = put(OYSTER, LOC_NE, STATE_FOUND); - game.prop[LAMP] = put(LAMP, LOC_NE, LAMP_DARK); - game.prop[ROD] = put(ROD, LOC_NE, STATE_FOUND); - game.prop[DWARF] = put(DWARF, LOC_NE, 0); + put(BOTTLE, LOC_NE, EMPTY_BOTTLE); + put(PLANT, LOC_NE, PLANT_THIRSTY); + put(OYSTER, LOC_NE, STATE_FOUND); + put(LAMP, LOC_NE, LAMP_DARK); + put(ROD, LOC_NE, STATE_FOUND); + put(DWARF, LOC_NE, STATE_FOUND); game.loc = LOC_NE; game.oldloc = LOC_NE; game.newloc = LOC_NE; /* Leave the grate with normal (non-negative) property. * Reuse sign. */ - put(GRATE, LOC_SW, 0); - put(SIGN, LOC_SW, 0); - game.prop[SIGN] = ENDGAME_SIGN; - game.prop[SNAKE] = put(SNAKE, LOC_SW, SNAKE_CHASED); - game.prop[BIRD] = put(BIRD, LOC_SW, BIRD_CAGED); - game.prop[CAGE] = put(CAGE, LOC_SW, STATE_FOUND); - game.prop[ROD2] = put(ROD2, LOC_SW, STATE_FOUND); - game.prop[PILLOW] = put(PILLOW, LOC_SW, STATE_FOUND); - - game.prop[MIRROR] = put(MIRROR, LOC_NE, STATE_FOUND); - game.fixed[MIRROR] = LOC_SW; + move(GRATE, LOC_SW); + move(SIGN, LOC_SW); + game.objects[SIGN].prop = ENDGAME_SIGN; + put(SNAKE, LOC_SW, SNAKE_CHASED); + put(BIRD, LOC_SW, BIRD_CAGED); + put(CAGE, LOC_SW, STATE_FOUND); + put(ROD2, LOC_SW, STATE_FOUND); + put(PILLOW, LOC_SW, STATE_FOUND); + + put(MIRROR, LOC_NE, STATE_FOUND); + game.objects[MIRROR].fixed = LOC_SW; for (int i = 1; i <= NOBJECTS; i++) { - if (TOTING(i)) - DESTROY(i); + if (TOTING(i)) { + DESTROY(i); + } } rspeak(CAVE_CLOSED); game.closed = true; - return true; + return game.closed; } + lampcheck(); return false; } -static void lampcheck(void) -/* Check game limit and lamp timers */ -{ - if (game.prop[LAMP] == LAMP_BRIGHT) - --game.limit; - - /* 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. - * First following arm checks if the lamp and fresh batteries are - * here, in which case we replace the batteries and continue. - * Second is for other cases of lamp dying. Even after it goes - * out, he can explore outside for a while if desired. */ - if (game.limit <= WARNTIME) { - if (HERE(BATTERY) && game.prop[BATTERY] == FRESH_BATTERIES && HERE(LAMP)) { - rspeak(REPLACE_BATTERIES); - game.prop[BATTERY] = DEAD_BATTERIES; -#ifdef __unused__ - /* This code from the original game seems to have been faulty. - * No tests ever passed the guard, and with the guard removed - * the game hangs when the lamp limit is reached. - */ - if (TOTING(BATTERY)) - drop(BATTERY, game.loc); -#endif - game.limit += BATTERYLIFE; - game.lmwarn = false; - } else if (!game.lmwarn && HERE(LAMP)) { - game.lmwarn = true; - if (game.prop[BATTERY] == DEAD_BATTERIES) - rspeak(MISSING_BATTERIES); - else if (game.place[BATTERY] == LOC_NOWHERE) - rspeak(LAMP_DIM); - else - rspeak(GET_BATTERIES); - } - } - if (game.limit == 0) { - game.limit = -1; - game.prop[LAMP] = LAMP_DARK; - if (HERE(LAMP)) - rspeak(LAMP_OUT); - } -} - -static void listobjects(void) +static void listobjects(void) { /* 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 @@ -929,23 +949,34 @@ static void listobjects(void) * Similarly for chain; game.prop is initially CHAINING_BEAR (locked to * bear). These hacks are because game.prop=0 is needed to * get full score. */ -{ if (!DARK(game.loc)) { - ++game.abbrev[game.loc]; - for (int i = game.atloc[game.loc]; i != 0; i = game.link[i]) { + ++game.locs[game.loc].abbrev; + for (int i = game.locs[game.loc].atloc; i != 0; i = game.link[i]) { obj_t obj = i; - if (obj > NOBJECTS) + if (obj > NOBJECTS) { obj = obj - NOBJECTS; - if (obj == STEPS && TOTING(NUGGET)) + } + if (obj == STEPS && TOTING(NUGGET)) { continue; - if (game.prop[obj] < 0) { - if (game.closed) - continue; - game.prop[obj] = STATE_FOUND; - if (obj == RUG) - game.prop[RUG] = RUG_DRAGON; - if (obj == CHAIN) - game.prop[CHAIN] = CHAINING_BEAR; + } + /* (ESR) Warning: it looks like you could get away with + * running this code only on objects with the treasure + * property set. Nope. There is mystery here. + */ + if (PROP_IS_STASHED_OR_UNSEEN(obj)) { + if (game.closed) { + continue; + } + PROP_SET_FOUND(obj); + if (obj == RUG) { + game.objects[RUG].prop = RUG_DRAGON; + } + if (obj == CHAIN) { + game.objects[CHAIN].prop = CHAINING_BEAR; + } + if (obj == EGGS) { + game.seenbigwords = true; + } --game.tally; /* Note: There used to be a test here to see whether the * player had blown it so badly that he could never ever see @@ -962,34 +993,99 @@ static void listobjects(void) * gross blunder isn't likely to find everything else anyway * (so goes the rationalisation). */ } - int kk = game.prop[obj]; - if (obj == STEPS) - kk = (game.loc == game.fixed[STEPS]) + int kk = game.objects[obj].prop; + if (obj == STEPS) { + kk = (game.loc == game.objects[STEPS].fixed) ? STEPS_UP : STEPS_DOWN; - pspeak(obj, look, kk, true); + } + pspeak(obj, look, true, kk); } } } -void clear_command(command_t *cmd) -{ - cmd->verb = ACT_NULL; - game.oldobj = cmd->obj; - cmd->obj = NO_OBJECT; -} +/* Pre-processes a command input to see if we need to tease out a few specific cases: + * - "enter water" or "enter stream": + * weird specific case that gets the user wet, and then kicks us back to get another command + * - : + * Irregular form of input, but should be allowed. We switch back to form for + * further processing. + * - "grate": + * If in location with grate, we move to that grate. If we're in a number of other places, + * we move to the entrance. + * - "water plant", "oil plant", "water door", "oil door": + * Change to "pour water" or "pour oil" based on context + * - "cage bird": + * If bird is present, we change to "carry bird" + * + * Returns true if pre-processing is complete, and we're ready to move to the primary command + * processing, false otherwise. */ +static bool preprocess_command(command_t *command) { + if (command->word[0].type == MOTION && command->word[0].id == ENTER + && (command->word[1].id == STREAM || command->word[1].id == WATER)) { + if (LIQLOC(game.loc) == WATER) { + rspeak(FEET_WET); + } else { + rspeak(WHERE_QUERY); + } + } else { + if (command->word[0].type == OBJECT) { + /* From OV to VO form */ + if (command->word[1].type == ACTION) { + command_word_t stage = command->word[0]; + command->word[0] = command->word[1]; + command->word[1] = stage; + } -static bool do_command() -/* Get and execute a command */ -{ - static command_t command; + if (command->word[0].id == GRATE) { + command->word[0].type = MOTION; + if (game.loc == LOC_START || + game.loc == LOC_VALLEY || + game.loc == LOC_SLIT) { + command->word[0].id = DEPRESSION; + } + if (game.loc == LOC_COBBLE || + game.loc == LOC_DEBRIS || + game.loc == LOC_AWKWARD || + game.loc == LOC_BIRDCHAMBER || + game.loc == LOC_PITTOP) { + command->word[0].id = ENTRANCE; + } + } + if ((command->word[0].id == WATER || command->word[0].id == OIL) && + (command->word[1].id == PLANT || command->word[1].id == DOOR)) { + if (AT(command->word[1].id)) { + command->word[1] = command->word[0]; + command->word[0].id = POUR; + command->word[0].type = ACTION; + strncpy(command->word[0].raw, "pour", LINESIZE - 1); + } + } + if (command->word[0].id == CAGE && command->word[1].id == BIRD && HERE(CAGE) && HERE(BIRD)) { + command->word[0].id = CARRY; + command->word[0].type = ACTION; + } + } + + /* If no word type is given for the first word, we assume it's a motion. */ + if (command->word[0].type == NO_WORD_TYPE) + command->word[0].type = MOTION; + + command->state = PREPROCESSED; + return true; + } + return false; +} +static bool do_move(void) { +/* Actually execute the move to the new location and dwarf movement */ /* Can't leave cave once it's closing (except by main office). */ if (OUTSID(game.newloc) && game.newloc != 0 && game.closng) { rspeak(EXIT_CLOSED); game.newloc = game.loc; - if (!game.panic) + if (!game.panic) { game.clock2 = PANICTIME; + } game.panic = true; } @@ -999,7 +1095,7 @@ static bool do_command() * place) let him get out (and attacked). */ if (game.newloc != game.loc && !FORCED(game.loc) && !CNDBIT(game.loc, COND_NOARRR)) { for (size_t i = 1; i <= NDWARVES - 1; i++) { - if (game.odloc[i] == game.newloc && game.dseen[i]) { + if (game.dwarves[i].oldloc == game.newloc && game.dwarves[i].seen) { game.newloc = game.loc; rspeak(DWARF_BLOCK); break; @@ -1008,212 +1104,334 @@ static bool do_command() } game.loc = game.newloc; - if (!dwarfmove()) + if (!dwarfmove()) { croak(); + } - /* Describe the current location and (maybe) get next command. */ + if (game.loc == LOC_NOWHERE) { + croak(); + } + + /* The easiest way to get killed is to fall into a pit in + * pitch darkness. */ + if (!FORCED(game.loc) && DARK(game.loc) && game.wzdark && PCT(PIT_KILL_PROB)) { + rspeak(PIT_FALL); + game.oldlc2 = game.loc; + croak(); + return false; + } + + return true; +} + +static bool do_command(void) { +/* Get and execute a command */ + static command_t command; + clear_command(&command); + + /* Describe the current location and (maybe) get next command. */ + while (command.state != EXECUTED) { + describe_location(); - for (;;) { - if (game.loc == 0) - croak(); - const char* msg = locations[game.loc].description.small; - if (MOD(game.abbrev[game.loc], game.abbnum) == 0 || - msg == 0) - msg = locations[game.loc].description.big; - if (!FORCED(game.loc) && DARK(game.loc)) { - /* The easiest way to get killed is to fall into a pit in - * pitch darkness. */ - if (game.wzdark && PCT(35)) { - rspeak(PIT_FALL); - game.oldlc2 = game.loc; - croak(); - continue; /* back to top of main interpreter loop */ - } - msg = arbitrary_messages[PITCH_DARK]; - } - if (TOTING(BEAR)) - rspeak(TAME_BEAR); - speak(msg); if (FORCED(game.loc)) { playermove(HERE); return true; } - if (game.loc == LOC_Y2 && PCT(25) && !game.closng) - rspeak(SAYS_PLUGH); listobjects(); - clear_command(&command); - -Lcheckhint: - checkhints(); - - /* If closing time, check for any objects being toted with - * game.prop < 0 and stash them. This way objects won't be - * described until they've been picked up and put down - * separate from their respective piles. */ - if (game.closed) { - if (game.prop[OYSTER] < 0 && TOTING(OYSTER)) - pspeak(OYSTER, look, 1, true); - for (size_t i = 1; i <= NOBJECTS; i++) { - if (TOTING(i) && game.prop[i] < 0) - game.prop[i] = STASHED(i); - } - } - game.wzdark = DARK(game.loc); - if (game.knfloc > 0 && game.knfloc != game.loc) - game.knfloc = 0; - // Get command input from user - if (!get_command_input(&command)) - return false; + /* Command not yet given; keep getting commands from user + * until valid command is both given and executed. */ + clear_command(&command); + while (command.state <= GIVEN) { + + if (game.closed) { + /* If closing time, check for any stashed objects + * being toted and unstash them. This way objects + * won't be described until they've been picked up + * and put down separate from their respective + * piles. */ + if ((PROP_IS_NOTFOUND(OYSTER) || PROP_IS_STASHED(OYSTER)) && TOTING(OYSTER)) { + pspeak(OYSTER, look, true, 1); + } + for (size_t i = 1; i <= NOBJECTS; i++) { + if (TOTING(i) && (PROP_IS_NOTFOUND(i) || PROP_IS_STASHED(i))) + game.objects[i].prop = PROP_STASHED(i); + } + } -Lclosecheck: -#ifdef GDEBUG - /* Needs to stay synced with enum word_type_t */ - const char *types[] = {"NO_WORD_TYPE", "MOTION", "OBJECT", "ACTION", "NUMERIC"}; - /* needs to stay synced with enum speechpart */ - const char *roles[] = {"unknown", "intransitive", "transitive"}; - printf("Command: role = %s type1 = %s, id1 = %ld, type2 = %s, id2 = %ld\n", - roles[command.part], - types[command.word[0].type], - command.word[0].id, - types[command.word[1].type], - command.word[1].id); -#endif + /* Check to see if the room is dark. If the knife is here, + * and it's dark, the knife permanently disappears */ + game.wzdark = DARK(game.loc); + if (game.knfloc != LOC_NOWHERE && game.knfloc != game.loc) { + game.knfloc = LOC_NOWHERE; + } - ++game.turns; + /* Check some for hints, get input from user, increment + * turn, and pre-process commands. Keep going until + * pre-processing is done. */ + while ( command.state < PREPROCESSED ) { + checkhints(); + + /* Get command input from user */ + if (!get_command_input(&command)) { + return false; + } + + /* 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. + */ + game.foobar = (game.foobar > WORD_EMPTY) ? -game.foobar : WORD_EMPTY; + + ++game.turns; + preprocess_command(&command); + } - if (closecheck()) { - if (game.closed) + /* check if game is closed, and exit if it is */ + if (closecheck()) { return true; - } else - lampcheck(); - - if (command.word[0].type == MOTION && command.word[0].id == ENTER - && (command.word[1].id == STREAM || command.word[1].id == WATER)) { - if (LIQLOC(game.loc) == WATER) - rspeak(FEET_WET); - else - rspeak(WHERE_QUERY); - - clear_command(&command); - goto Lcheckhint; - } + } - if (command.word[0].type == OBJECT) { - if (command.word[0].id == GRATE) { - command.word[0].type = MOTION; - if (game.loc == LOC_START || - game.loc == LOC_VALLEY || - game.loc == LOC_SLIT) { - command.word[0].id = DEPRESSION; + /* loop until all words in command are processed */ + while (command.state == PREPROCESSED ) { + command.state = PROCESSING; + + if (command.word[0].id == WORD_NOT_FOUND) { + /* Gee, I don't understand. */ + sspeak(DONT_KNOW, command.word[0].raw); + clear_command(&command); + continue; } - if (game.loc == LOC_COBBLE || - game.loc == LOC_DEBRIS || - game.loc == LOC_AWKWARD || - game.loc == LOC_BIRD || - game.loc == LOC_PITTOP) { - command.word[0].id = ENTRANCE; + /* Give user hints of shortcuts */ + if (strncasecmp(command.word[0].raw, "west", sizeof("west")) == 0) { + if (++game.iwest == 10) { + rspeak(W_IS_WEST); + } } - } - if ((command.word[0].id == WATER || command.word[0].id == OIL) && (command.word[1].id == PLANT || command.word[1].id == DOOR)) { - if (AT(command.word[1].id)) { - command.word[1] = command.word[0]; - command.word[0].id = POUR; - command.word[0].type = ACTION; - strncpy(command.word[0].raw, "pour", LINESIZE - 1); + if (strncasecmp(command.word[0].raw, "go", sizeof("go")) == 0 && command.word[1].id != WORD_EMPTY) { + if (++game.igo == 10) { + rspeak(GO_UNNEEDED); + } } - } - if (command.word[0].id == CAGE && command.word[1].id == BIRD && HERE(CAGE) && HERE(BIRD)) { - command.word[0].id = CARRY; - command.word[0].type = ACTION; - } - /* From OV to VO form */ - if (command.word[0].type == OBJECT && command.word[1].type == ACTION) { - command_word_t stage = command.word[0]; - command.word[0] = command.word[1]; - command.word[1] = stage; - } - } + switch (command.word[0].type) { + case MOTION: + playermove(command.word[0].id); + command.state = EXECUTED; + continue; + case OBJECT: + command.part = unknown; + command.obj = command.word[0].id; + break; + case ACTION: + if (command.word[1].type == NUMERIC) { + command.part = transitive; + } else { + command.part = intransitive; + } + command.verb = command.word[0].id; + break; + case NUMERIC: + if (!settings.oldstyle) { + sspeak(DONT_KNOW, command.word[0].raw); + clear_command(&command); + continue; + } + break;// LCOV_EXCL_LINE + default: // LCOV_EXCL_LINE + case NO_WORD_TYPE: // LCOV_EXCL_LINE + BUG(VOCABULARY_TYPE_N_OVER_1000_NOT_BETWEEN_0_AND_3); // LCOV_EXCL_LINE + } -Lookup: - if (strncasecmp(command.word[0].raw, "west", sizeof("west")) == 0) { - if (++game.iwest == 10) - rspeak(W_IS_WEST); - } - if (strncasecmp(command.word[0].raw, "go", sizeof("go")) == 0 && command.word[1].id != WORD_EMPTY) { - if (++game.igo == 10) - rspeak(GO_UNNEEDED); - } - if (command.word[0].id == WORD_NOT_FOUND) { - /* Gee, I don't understand. */ - sspeak(DONT_KNOW, command.word[0].raw); - clear_command(&command); - goto Lcheckhint; - } - switch (command.word[0].type) { - case NO_WORD_TYPE: // FIXME: treating NO_WORD_TYPE as a motion word is confusing - case MOTION: - playermove(command.word[0].id); - return true; - case OBJECT: - command.part = unknown; - command.obj = command.word[0].id; + switch (action(command)) { + case GO_TERMINATE: + command.state = EXECUTED; + break; + case GO_MOVE: + playermove(NUL); + command.state = EXECUTED; + break; + case GO_WORD2: +#ifdef GDEBUG + printf("Word shift\n"); +#endif /* GDEBUG */ + /* Get second word for analysis. */ + command.word[0] = command.word[1]; + command.word[1] = empty_command_word; + command.state = PREPROCESSED; + break; + case GO_UNKNOWN: + /* Random intransitive verbs come here. Clear obj just in case + * (see attack()). */ + command.word[0].raw[0] = toupper(command.word[0].raw[0]); + sspeak(DO_WHAT, command.word[0].raw); + command.obj = NO_OBJECT; + + /* object cleared; we need to go back to the preprocessing step */ + command.state = GIVEN; + break; + case GO_CHECKHINT: // FIXME: re-name to be more contextual; this was previously a label + command.state = GIVEN; + break; + case GO_DWARFWAKE: + /* Oh dear, he's disturbed the dwarves. */ + rspeak(DWARVES_AWAKEN); + terminate(endgame); + case GO_CLEAROBJ: // FIXME: re-name to be more contextual; this was previously a label + clear_command(&command); + break; + case GO_TOP: // FIXME: re-name to be more contextual; this was previously a label + break; + default: // LCOV_EXCL_LINE + BUG(ACTION_RETURNED_PHASE_CODE_BEYOND_END_OF_SWITCH); // LCOV_EXCL_LINE + } + } /* while command has not been fully processed */ + } /* while command is not yet given */ + } /* while command is not executed */ + + /* command completely executed; we return true. */ + return true; +} + +/* + * MAIN PROGRAM + * + * Adventure (rev 2: 20 treasures) + * History: Original idea & 5-treasure version (adventures) by Willie Crowther + * 15-treasure version (adventure) by Don Woods, April-June 1977 + * 20-treasure version (rev 2) by Don Woods, August 1978 + * Errata fixed: 78/12/25 + * Revived 2017 as Open Adventure. + */ + +int main(int argc, char *argv[]) +{ + int ch; + + /* Options. */ + +#if defined ADVENT_AUTOSAVE + const char* opts = "dl:oa:"; + const char* usage = "Usage: %s [-l logfilename] [-o] [-a filename] [script...]\n"; + FILE *rfp = NULL; + const char* autosave_filename = NULL; +#elif !defined ADVENT_NOSAVE + const char* opts = "dl:or:"; + const char* usage = "Usage: %s [-l logfilename] [-o] [-r restorefilename] [script...]\n"; + FILE *rfp = NULL; +#else + const char* opts = "dl:o"; + const char* usage = "Usage: %s [-l logfilename] [-o] [script...]\n"; +#endif + while ((ch = getopt(argc, argv, opts)) != EOF) { + switch (ch) { + case 'd': // LCOV_EXCL_LINE + settings.debug +=1; // LCOV_EXCL_LINE + break; // LCOV_EXCL_LINE + case 'l': + settings.logfp = fopen(optarg, "w"); + if (settings.logfp == NULL) { + fprintf(stderr, + "advent: can't open logfile %s for write\n", + optarg); + } + signal(SIGINT, sig_handler); + break; + case 'o': + settings.oldstyle = true; + settings.prompt = false; break; - case ACTION: - if (command.word[1].type == NUMERIC) - command.part = transitive; - else - command.part = intransitive; - command.verb = command.word[0].id; +#ifdef ADVENT_AUTOSAVE + case 'a': + rfp = fopen(optarg, READ_MODE); + autosave_filename = optarg; + signal(SIGHUP, sig_handler); + signal(SIGTERM, sig_handler); break; - case NUMERIC: - if (!settings.oldstyle) { - sspeak(DONT_KNOW, command.word[0].raw); - clear_command(&command); - goto Lcheckhint; +#elif !defined ADVENT_NOSAVE + case 'r': + rfp = fopen(optarg, "r"); + if (rfp == NULL) { + fprintf(stderr, + "advent: can't open save file %s for read\n", + optarg); } - default: // LCOV_EXCL_LINE - BUG(VOCABULARY_TYPE_N_OVER_1000_NOT_BETWEEN_0_AND_3); // LCOV_EXCL_LINE + break; +#endif + default: + fprintf(stderr, + usage, argv[0]); + fprintf(stderr, + " -l create a log file of your game named as specified'\n"); + fprintf(stderr, + " -o 'oldstyle' (no prompt, no command editing, displays 'Initialising...')\n"); +#if defined ADVENT_AUTOSAVE + fprintf(stderr, + " -a automatic save/restore from specified saved game file\n"); +#elif !defined ADVENT_NOSAVE + fprintf(stderr, + " -r restore from specified saved game file\n"); +#endif + exit(EXIT_FAILURE); + break; } - switch (action(command)) { - case GO_TERMINATE: - return true; - case GO_MOVE: - playermove(NUL); - return true; - case GO_TOP: - continue; /* back to top of main interpreter loop */ - case GO_CLEAROBJ: - clear_command(&command); - /* FALL THROUGH */ - case GO_CHECKHINT: - goto Lcheckhint; - case GO_WORD2: -#ifdef GDEBUG - printf("Word shift\n"); -#endif /* GDEBUG */ - /* Get second word for analysis. */ - command.word[0] = command.word[1]; - command.word[1] = empty_command_word; - goto Lookup; - case GO_UNKNOWN: - /* Random intransitive verbs come here. Clear obj just in case - * (see attack()). */ - command.word[0].raw[0] = toupper(command.word[0].raw[0]); - sspeak(DO_WHAT, command.word[0].raw); - command.obj = 0; - goto Lcheckhint; - case GO_DWARFWAKE: - /* Oh dear, he's disturbed the dwarves. */ - rspeak(DWARVES_AWAKEN); - terminate(endgame); - default: // LCOV_EXCL_LINE - BUG(ACTION_RETURNED_PHASE_CODE_BEYOND_END_OF_SWITCH); // LCOV_EXCL_LINE + } + + /* copy invocation line part after switches */ + settings.argc = argc - optind; + settings.argv = argv + optind; + settings.optind = 0; + + /* Initialize game variables */ + int seedval = initialise(); + +#if !defined ADVENT_NOSAVE + if (!rfp) { + game.novice = yes_or_no(arbitrary_messages[WELCOME_YOU], arbitrary_messages[CAVE_NEARBY], arbitrary_messages[NO_MESSAGE]); + if (game.novice) { + game.limit = NOVICELIMIT; + } + } else { + restore(rfp); +#if defined ADVENT_AUTOSAVE + score(scoregame); +#endif + } +#if defined ADVENT_AUTOSAVE + if (autosave_filename != NULL) { + if ((autosave_fp = fopen(autosave_filename, WRITE_MODE)) == NULL) { + perror(autosave_filename); + return EXIT_FAILURE; } + autosave(); + } +#endif +#else + game.novice = yes_or_no(arbitrary_messages[WELCOME_YOU], arbitrary_messages[CAVE_NEARBY], arbitrary_messages[NO_MESSAGE]); + if (game.novice) + game.limit = NOVICELIMIT; +#endif + + if (settings.logfp) { + fprintf(settings.logfp, "seed %d\n", seedval); } + + /* interpret commands until EOF or interrupt */ + for (;;) { + // if we're supposed to move, move + if (!do_move()) { + continue; + } + + // get command + if (!do_command()) { + break; + } + } + /* show score and exit */ + terminate(quitgame); } /* end */