diff options
Diffstat (limited to 'engines/glk/agt/exec.cpp')
| -rw-r--r-- | engines/glk/agt/exec.cpp | 1375 |
1 files changed, 1375 insertions, 0 deletions
diff --git a/engines/glk/agt/exec.cpp b/engines/glk/agt/exec.cpp new file mode 100644 index 0000000000..983002aa44 --- /dev/null +++ b/engines/glk/agt/exec.cpp @@ -0,0 +1,1375 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/agt/agility.h" +#include "glk/agt/interp.h" +#include "glk/agt/exec.h" + +namespace Glk { +namespace AGT { + +/* This file contains the wrapper for running player commands, + routines run at the end of the turn, and various other functions + needed by runverb.c and token.c. */ + +#define global + +static rbool pronoun_mode; + +word realverb = 0; /* Name of current verb. (normally ~= input[vp])*/ + + +/* ------------------------------------------------------------------- */ +/* High level output functions, used for printing messages, error */ +/* messages, and everything else. They call the direct output functions */ +/* in interface.c The reason they're in runverb.c is that they need to */ +/* access item info in order to fill in the blanks */ + + +/* This updates the contents of compass_rose, which can be used by the + OS layer to print out some sort of representation of which way the + player can go. */ + +static void set_compass_rose(void) { + int i, bit; + + compass_rose = 0; + if (!islit()) return; /* No compass in darkness */ + for (i = 0, bit = 1; i < 12; i++, bit <<= 1) + if (troom(room[loc].path[i])) compass_rose |= bit; +} + +static void time_out(char *s) { + int hr, min; + + hr = curr_time / 100; + min = curr_time % 100; + + if (milltime_mode) + sprintf(s, "%02d:%02d", hr, min); + else { + if (hr > 12) hr = hr - 12; + if (hr == 0) hr = 12; + sprintf(s, "%2d:%02d %s", hr, min, (curr_time >= 1200) ? "pm" : "am"); + } +} + + + + + +void set_statline() { + char timestr[20]; + + recompute_score(); + set_compass_rose(); + + rstrncpy(l_stat, room[loc].name, 81); + + time_out(timestr); + + switch (statusmode) { + case 0: + sprintf(r_stat, "Score: %ld Moves: %d", tscore, turncnt); + break; + case 1: + sprintf(r_stat, "Score: %ld %s", tscore, timestr); + break; + case 2: + sprintf(r_stat, "Moves: %d", turncnt); + break; + case 3: + sprintf(r_stat, "%s", timestr); + break; + case 4: + r_stat[0] = '\0'; + break; /* 'Trinity style' status line */ + case 5: + sprintf(r_stat, "Score: %ld", tscore); + break; + } +} + + +/* -------------------------------------------------------------------- */ +/* Message printing / $ substitution Routines */ +/* -------------------------------------------------------------------- */ + +#define FILL_SIZE 100 + + +/* Tries to convert *pstr to a number, which it returns. + If it fails, or if the number is not in the range 0..maxval, + it returns -1. + It advances *pstr to point after the number and after the + terminating character, if relevant. + <term_char> is the terminating character; if this is 0, then + the calling routine will worry about the terminating character. + <maxval> of 0 indicates no upper bound +*/ + +static int extract_number(const char **pstr, int maxval, + char term_char) { + const char *s; + long n; /* n holds the value to be returned; i holds + the number of characters parsed. */ + n = 0; + s = *pstr; + while (*s == ' ' || *s == '\t') s++; + for (; *s != 0; s++) { + if (*s < '0' || *s > '9') break; + n = 10 * n + (*s - '0'); + if (maxval && n > maxval) return -1; + } + if (term_char) { + if (*s == term_char) s++; + else return -1; + } + *pstr = s; + return n; +} + +#define BAD_PROP (-1000) + +/* This is used by #PROP[obj].[prop]# and $ATTR[obj].[attr]$, etc. */ +/* isprop: Are we looking for a property (as opposed to an attribute)? */ +static void extract_prop_val(const char **pstr, + int *id, int *val, + rbool isprop, const char term_char) { + const char *s; + int v; /* object number / final value */ + int i; /* Attribute id */ + rbool builtin; /* Expect builtin property or attribute? */ + + *id = i = BAD_PROP; + *val = 0; /* Failure case by default */ + builtin = 0; + s = *pstr; + if (match_str(&s, "NOUN")) v = dobj; + else if (match_str(&s, "OBJECT")) v = iobj; + else v = extract_number(&s, maxcreat, 0); /* Must be object number */ + while (*s == '.') { + s++; + if (*s == '-') { + builtin = 1; + s++; + } else + builtin = 0; + i = extract_number(&s, 0, 0); + if (!troom(v) && !tnoun(v) && !tcreat(v)) { + i = -1; + continue; + } + if (isprop || *s == '.') /* Treat as property */ + v = builtin ? getprop(v, i) : op_objprop(2, v, i, 0); + else /* Treat as attribute */ + v = builtin ? getattr(v, i) : op_objflag(2, v, i); + } + if (*s != term_char) return; + *pstr = s + 1; + if (i < 0) return; + *id = builtin ? -1 : i; + *val = v; +} + + + + +static word it_pronoun(int item, rbool ind_form) +/* Return the correct pronoun to go with item; + ind_form is 1 if we want the object form, 0 if we want the + subject form */ +{ + if (it_plur(item)) + return (ind_form ? ext_code[wthem] : ext_code[wthey]); + if (tcreat(item)) + switch (creature[item - first_creat].gender) { + case 0: + return ext_code[wit]; + case 1: + return (ind_form ? ext_code[wher] : ext_code[wshe]); + case 2: + return (ind_form ? ext_code[whim] : ext_code[whe]); + } + return ext_code[wit]; +} + +/* This sets the value of "The" for the given noun. */ +/* (In particular, proper nouns shouldn't have a "the") */ +static void theset(char *buff, int item) { + if (it_proper(item)) + strcpy(buff, ""); + else + strcpy(buff, "the "); +} + + +static void num_name_func(parse_rec *obj_rec, char *fill_buff, word prev_adj) +/* This is a subroutine to wordcode_match. */ +/* It gives either a noun name or a number, depending. */ +/* prev_adj is a word if this was preceded by its associated $adjective$; + the goal is to avoid having $adjective$ $noun$ expand to (e.g.) + 'silver silver' when the player types in "get silver" to pick up + a magic charm with synonym 'silver'. */ +{ + word w; + + if (obj_rec == NULL) { + strcpy(fill_buff, ""); + return; + } + + w = 0; + if (obj_rec->noun != 0) w = obj_rec->noun; + if ((w == 0 || w == prev_adj) && obj_rec->obj != 0) + w = it_name(obj_rec->obj); + + if (w == 0) { + if (obj_rec->info == D_NUM) sprintf(fill_buff, "%ld", (long)obj_rec->num); + else strcpy(fill_buff, ""); +#if 0 + strcpy(fill_buff, "that"); /* We can try and hope */ +#endif + return; + } + + if (w == prev_adj) /* ... and prev_adj!=0 but we don't need to explicity + test that since w!=0 */ + fill_buff[0] = 0; /* i.e. an empty string */ + else { + rstrncpy(fill_buff, dict[w], FILL_SIZE); + if (it_proper(obj_rec->obj)) fill_buff[0] = toupper(fill_buff[0]); + } +} + +static word get_adj(parse_rec *obj_rec, char *buff) { + word w; + + if (obj_rec->adj != 0) w = obj_rec->adj; + else w = it_adj(obj_rec->obj); + + if (w == 0) strcpy(buff, ""); + else { + rstrncpy(buff, dict[w], FILL_SIZE); + if (it_proper(obj_rec->obj)) buff[0] = toupper(buff[0]); + } + + return w; +} + + + +#define d2buff(i) {rstrncpy(fill_buff,dict[i],FILL_SIZE);return 1;} +#define num_name(obj_rec,jsa) {num_name_func(obj_rec,fill_buff,jsa);return 1;} +/* jsa= Just seen adj */ +#define youme(mestr,youstr) {strcpy(fill_buff,irun_mode?mestr:youstr);\ + return 1;} + +word just_seen_adj; /* This determines if we just saw $adjective$; if so, + this is set to it, otherwise it is zero. See + num_name_func above. */ + +static int wordcode_match(const char **pvarname, char *fill_buff, + int context, const char *pword) +/* Check <*p*pvarname> for a match; put subs text in fill_buf + <context> indicates who called us; this determines + what substitutions are valid. See interp.h for possible + values. Move *p*pvarname after whatever is matched. + <pword> contains the parse word when context is MSG_PARSE. */ +/* $ forms: + $verb$, $noun$, $adjective$, $prep$, $object$, $name$, + $n_pro$, $o_pro$, $n_indir$, $o_indir$, + $name_pro$, $name_indir$ + $n_is$, $o_is$, $name_is$ + $c_name$ + $n_was$, $o_was$, $name_was$ + $the_n$, $the_o$, $the_name$ + */ +/* Also $STRn$, $FLAGn$, $ONn$, $OPENn$, $LOCKEDn$ */ +/* Support for FLAG, ON, OPEN, and LOCKED added by Mitch Mlinar */ +/* Return 0 if no match, 1 if there is */ +{ + int hold_val, hold_id; + + fill_buff[0] = 0; /* By default, return "\0" string */ + if (match_str(pvarname, "STR")) { /* String variable */ + hold_id = extract_number(pvarname, MAX_USTR, '$'); + if (hold_id < 1) return 0; + rstrncpy(fill_buff, userstr[hold_id - 1], FILL_SIZE); + return 1; + } else if (match_str(pvarname, "VAR")) { + hold_id = extract_number(pvarname, VAR_NUM, '$'); + if (hold_id < 0) return 0; + hold_val = agt_var[hold_id]; + rstrncpy(fill_buff, + get_objattr_str(AGT_VAR, hold_id, hold_val), FILL_SIZE); + return 1; + } else if (match_str(pvarname, "FLAG")) { + hold_id = extract_number(pvarname, FLAG_NUM, '$'); + if (hold_id < 0) return 0; + rstrncpy(fill_buff, + get_objattr_str(AGT_FLAG, hold_id, flag[hold_id]), FILL_SIZE); + return 1; + } else if (match_str(pvarname, "ATTR")) { + extract_prop_val(pvarname, &hold_id, &hold_val, 0, '$'); + if (hold_id == BAD_PROP) return 1; + rstrncpy(fill_buff, + get_objattr_str(AGT_OBJFLAG, hold_id, hold_val), FILL_SIZE); + return 1; + } else if (match_str(pvarname, "PROP")) { + extract_prop_val(pvarname, &hold_id, &hold_val, 1, '$'); + if (hold_id == BAD_PROP) return 1; + rstrncpy(fill_buff, + get_objattr_str(AGT_OBJPROP, hold_id, hold_val), FILL_SIZE); + return 1; + } else if (match_str(pvarname, "OPEN")) { + hold_val = extract_number(pvarname, maxnoun, '$'); + strcpy(fill_buff, it_open(hold_val) ? "open" : "closed"); + return 1; + } else if (match_str(pvarname, "ON")) { + hold_val = extract_number(pvarname, maxnoun, '$'); + strcpy(fill_buff, it_on(hold_val) ? "on" : "off"); + return 1; + } else if (match_str(pvarname, "LOCKED")) { + hold_val = extract_number(pvarname, maxnoun, '$'); + strcpy(fill_buff, it_locked(hold_val, 0) ? "locked" : "unlocked"); + return 1; + } + + if (context == MSG_MAIN) return 0; + + if (context == MSG_PARSE) { + /* The only special subsitution allowed is $word$. */ + if (match_str(pvarname, "WORD$")) { + if (pword == NULL) fill_buff[0] = 0; + else rstrncpy(fill_buff, pword, FILL_SIZE); + return 1; + } else return 0; + } + + /* d2buff is a macro that returns 1 */ + if (match_str(pvarname, "NOUN$")) + num_name(dobj_rec, just_seen_adj); + just_seen_adj = 0; /* It doesn't matter. */ + if (match_str(pvarname, "VERB$")) + d2buff(realverb); /* auxsyn[vb][0] */ + if (match_str(pvarname, "OBJECT$")) + num_name(iobj_rec, 0); + if (match_str(pvarname, "NAME$")) + num_name(actor_rec, 0); + if (match_str(pvarname, "ADJECTIVE$")) { + just_seen_adj = get_adj(dobj_rec, fill_buff); + return 1; + } + if (match_str(pvarname, "PREP$")) + d2buff(prep); + if (match_str(pvarname, "N_PRO$")) + d2buff(it_pronoun(dobj, 0)); + if (match_str(pvarname, "O_PRO$")) + d2buff(it_pronoun(iobj, 0)); + if (match_str(pvarname, "NAME_PRO$")) + d2buff(it_pronoun(actor, 0)); + if (match_str(pvarname, "N_INDIR$")) + d2buff(it_pronoun(dobj, 1)); + if (match_str(pvarname, "O_INDIR$")) + d2buff(it_pronoun(iobj, 1)); + if (match_str(pvarname, "NAME_INDIR$")) + d2buff(it_pronoun(actor, 1)); + if (match_str(pvarname, "N_IS$")) { + if (!it_plur(dobj)) d2buff(ext_code[wis]) + else d2buff(ext_code[ware]); + } + if (match_str(pvarname, "O_IS$")) { + if (!it_plur(iobj)) d2buff(ext_code[wis]) + else d2buff(ext_code[ware]); + } + if (match_str(pvarname, "NAME_IS$")) { + if (!it_plur(actor)) d2buff(ext_code[wis]) + else d2buff(ext_code[ware]); + } + + if (match_str(pvarname, "N_WAS$")) { + if (!it_plur(dobj)) d2buff(ext_code[wwas]) + else d2buff(ext_code[wwere]); + } + if (match_str(pvarname, "O_WAS$")) { + if (!it_plur(iobj)) d2buff(ext_code[wwas]) + else d2buff(ext_code[wwere]); + } + if (match_str(pvarname, "NAME_WAS$")) { + if (!it_plur(actor)) d2buff(ext_code[wwas]) + else d2buff(ext_code[wwere]); + } + if (match_str(pvarname, "THE_N$")) { + theset(fill_buff, dobj); + return 1; + } + if (match_str(pvarname, "THE_O$")) { + theset(fill_buff, iobj); + return 1; + } + if (match_str(pvarname, "THE_NAME$")) { + theset(fill_buff, actor); + return 1; + } + if (match_str(pvarname, "THE_C$")) { + theset(fill_buff, curr_creat_rec->obj); + return 1; + } + if (match_str(pvarname, "C_NAME$")) + num_name(curr_creat_rec, 0); + if (match_str(pvarname, "TIME$")) { + time_out(fill_buff); + return 1; + } + + if (pronoun_mode && match_str(pvarname, "YOU$")) + youme("I", "you"); + if (pronoun_mode && match_str(pvarname, "ARE$")) + youme("am", "are"); + if (pronoun_mode && match_str(pvarname, "YOU_OBJ$")) + youme("me", "you"); + if (pronoun_mode && match_str(pvarname, "YOUR$")) + youme("my", "your"); + if (pronoun_mode && match_str(pvarname, "YOU'RE$")) + youme("i'm", "you're"); + return 0; /* Don't recognize $word$ */ +} + + + +static int capstate(const char *varname) { + if (islower(varname[0])) return 0; /* $word$ */ + if (islower(varname[1])) return 2; /* $Word$ */ + if (!isalpha(varname[1]) && varname[1] != 0 + && islower(varname[2])) return 2; + else return 1; /* $WORD$ */ +} + +static char fill_buff[FILL_SIZE]; /* Buffer to hold returned string */ + +static char *wordvar_match(const char **pvarname, char match_type, + int context, const char *pword) +/* Match_type=='#' for variables, '$' for parsed words */ +/* Possible # forms: #VARn#, #CNTn# */ +/* See above for $ forms */ +/* Moves *pvarname to point after matched object */ +{ + int i, hold_val, hold_prop; + const char *start; + + start = *pvarname; + if (match_type == '$') { + i = wordcode_match(pvarname, fill_buff, context, pword); + if (i == 0) return NULL; + /* Now need to fix capitalization */ + switch (capstate(start)) { + case 0: + break; /* $word$ */ + case 1: /* $WORD$ */ + for (i = 0; fill_buff[i] != '\0'; i++) + fill_buff[i] = toupper(fill_buff[i]); + break; + case 2: /* $Word$ */ + fill_buff[0] = toupper(fill_buff[0]); + break; + } + } else { /* So match type is '#' */ + if (match_str(pvarname, "VAR")) { + hold_val = extract_number(pvarname, VAR_NUM, '#'); + if (hold_val < 0) return NULL; + hold_val = agt_var[hold_val]; + } else if (match_str(pvarname, "CNT") || + match_str(pvarname, "CTR")) { + hold_val = extract_number(pvarname, CNT_NUM, '#'); + if (hold_val < 0) return NULL; + hold_val = cnt_val(agt_counter[hold_val]); + } else if (match_str(pvarname, "PROP")) { + extract_prop_val(pvarname, &hold_prop, &hold_val, 1, '#'); + if (hold_prop == BAD_PROP) hold_val = 0; + } else + return NULL; + + /* Now to convert hold_val into a string */ + sprintf(fill_buff, "%d", hold_val); + + } + return fill_buff; +} + +static char *format_line(const char *s, int context, const char *pword) +/* Do $word$ substituations; return the result */ +{ + char *t; /* The new string after all the substitutions. */ + int t_size; /* How much space has been allocated for it. */ + const char *p, *oldp; /* Pointer to the original string */ + int i; + char *fill_word, *q; /* Word used to fill in the blanks, and a pointer + used to iterate through it*/ + char fill_type; /* '#'=#variable#, '$'=$word$ */ + + /* Need to do subsitutions and also correct for tabs */ + t_size = 200; + t = (char *)rmalloc(t_size + FILL_SIZE + 10); + just_seen_adj = 0; + + /* Note that I leave some margin here: t is 310 characters, but i will never + be allowed above around 200. This is to avoid having to put special + checking code throughout the following to make sure t isn't overrun */ + for (p = s, i = 0; *p != '\0'; p++) { + if (i >= t_size) { + t_size = i + 100; + t = (char *)rrealloc(t, t_size + FILL_SIZE + 10); + } + if (!rspace(*p) && *p != '$') + just_seen_adj = 0; + if (*p == '$' || *p == '#') { + /* Read in $word$ or #var# and do substitution */ + fill_type = *p; + oldp = p++; /* Save old value in case we are wrong and then + increment p */ + fill_word = wordvar_match(&p, fill_type, context, pword); + if (fill_word == NULL) { + /*i.e. no match-- so just copy it verbatim */ + t[i++] = fill_type; + just_seen_adj = 0; + p = oldp; /* Go back and try again... */ + } else { /* Fill in word */ + p--; + if (fill_word[0] == '\0') { /* Empty string */ + /* We need to eliminate a 'double space' in this case */ + if ((oldp == s || rspace(*(oldp - 1))) && rspace(*(p + 1))) + p++; + } else /* Normal case */ + for (q = fill_word; *q != '\0';) + t[i++] = *q++; + } + } /* End $/# matcher */ + else + t[i++] = *p; + } /* End scanning loop */ + + if (aver < AGX00 && i > 0 && t[i - 1] == ' ') { + /* For pre-Magx, delete trailing spaces */ + do + i--; + while (i > 0 && t[i] == ' '); + i++; + } + t[i] = 0; + t = (char *)rrealloc(t, i + 1); + return t; +} + +void raw_lineout(const char *s, rbool do_repl, int context, const char *pword) { + char *outstr; + + if (do_repl) { + outstr = format_line(s, context, pword); + writestr(outstr); + rfree(outstr); + } else + writestr(s); +} + + +static void lineout(const char *s, rbool nl, int context, const char *pword) { + raw_lineout(s, 1, context, pword); + if (nl) writeln(""); + else writestr(" "); +} + +static void gen_print_descr(descr_ptr dp_, rbool nl, + int context, const char *pword) { + int j; + descr_line *txt; + + agt_textcolor(7); + textbold = 0; + agt_par(1); + txt = read_descr(dp_.start, dp_.size); + if (txt != NULL) + for (j = 0; txt[j] != NULL; j++) + lineout(txt[j], nl || (txt[j + 1] != NULL), context, pword); + free_descr(txt); + agt_par(0); + agt_textcolor(7); + textbold = 0; +} + +void print_descr(descr_ptr dp_, rbool nl) { + gen_print_descr(dp_, nl, MSG_DESC, NULL); +} + +void quote(int msgnum) { + char **qptr; + descr_line *txt; + int i; + int len; + + txt = read_descr(msg_ptr[msgnum - 1].start, msg_ptr[msgnum - 1].size); + if (txt != NULL) { + for (len = 0; txt[len] != NULL; len++); + qptr = (char **)rmalloc(len * sizeof(char *)); + for (i = 0; i < len; i++) + qptr[i] = format_line(txt[i], MSG_DESC, NULL); + free_descr(txt); + textbox(qptr, len, TB_BORDER | TB_CENTER); + rfree(qptr); + } +} + + +void msgout(int msgnum, rbool add_nl) { + print_descr(msg_ptr[msgnum - 1], add_nl); +} + + +#define MAX_NUM_ERR 240 /* Highest numbered STANDARD message */ +#define OLD_MAX_STD_MSG 185 + +/* Fallback messages should always have msgid less than the original */ +int stdmsg_fallback[MAX_NUM_ERR - OLD_MAX_STD_MSG] = { + 0, 0, 0, 12, 0, /* 186 - 190 */ + 0, 0, 0, 0, 0, /* 191 - 195 */ + 0, 13, 13, 5, 10, /* 196 - 200 */ + 10, 61, 10, 16, 59, /* 201 - 205 */ + 90, 107, 116, 135, 140, /* 206 - 210 */ + 184, 3, 47, 185, 61, /* 211 - 215 */ + 0, 0, 0, 0, 0, /* 216 - 220 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 221 - 230 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 231 - 240 */ +}; + +void gen_sysmsg(int msgid, const char *s, int context, const char *pword) +/* Prints either STANDARD message number <msgid> or default msg <s>; + A <msgid> of 0 means there is no standard message counterpart. + <context> determines what $$ substitutions are meaningful + <parseword> gives the $pword$ substitution for MSG_PARSE messages + msgid 3 should probably *not* be redirected to avoid giving hints to + the player as to what nouns exist in the game. +*/ +{ + /* Use gamefile's redefined version of message? */ + rbool use_game_msg; + rbool nl; /* Should it be followed by a newline? */ + + nl = 1; /* By default, follow message with newline */ + + /* The following msgids shouldn't be followed by newlines: */ + if (msgid == 1 || msgid == 145 || (msgid >= 218 && msgid <= 223) + || msgid == 225) + nl = 0; + + if (DEBUG_SMSG) rprintf("\nSTD %d", msgid); + + use_game_msg = ((PURE_SYSMSG || s == NULL) + && msgid != 0 && msgid <= NUM_ERR + && err_ptr != NULL); + + if (use_game_msg) { + /* Check for fall-back messages */ + if (err_ptr[msgid - 1].size <= 0 + && msgid > OLD_MAX_STD_MSG && msgid <= MAX_NUM_ERR) { + msgid = stdmsg_fallback[msgid - OLD_MAX_STD_MSG - 1]; + if (DEBUG_SMSG) rprintf("==> %3d"); + } + if (msgid != 0 && err_ptr[msgid - 1].size > 0) { + if (DEBUG_SMSG) rprintf(" : From gamefile\n"); + gen_print_descr(err_ptr[msgid - 1], nl, context, pword); + } else use_game_msg = 0; + } + + if (DEBUG_SMSG && !use_game_msg) rprintf(" : Default\n"); + + if (!use_game_msg) { + /* Either the game doesn't redefine the message, or we're ignoring + redefinitions */ + if (s == NULL) return; + pronoun_mode = 1; + lineout(s, nl, context, pword); + pronoun_mode = !PURE_PROSUB; + } +} + + +void sysmsg(int msgid, const char *s) { + gen_sysmsg(msgid, s, MSG_RUN, NULL); +} + + +void alt_sysmsg(int msgid, const char *s, parse_rec *new_dobjrec, parse_rec *new_iobjrec) { + parse_rec *save_dobjrec, *save_iobjrec; + integer save_dobj, save_iobj; + + save_dobj = dobj; + save_dobjrec = dobj_rec; + dobj = p_obj(new_dobjrec); + dobj_rec = new_dobjrec; + + save_iobj = iobj; + save_iobjrec = iobj_rec; + iobj = p_obj(new_iobjrec); + iobj_rec = new_iobjrec; + + gen_sysmsg(msgid, s, MSG_RUN, NULL); + + dobj = save_dobj; + dobj_rec = save_dobjrec; + iobj = save_iobj; + iobj_rec = save_iobjrec; +} + + +void sysmsgd(int msgid, const char *s, parse_rec *new_dobjrec) +/* Front end for sysmsg w/alternative direct object */ +{ + alt_sysmsg(msgid, s, new_dobjrec, NULL); +} + + +/* -------------------------------------------------------------------- */ +/* QUESTION and ANSWER processing */ +/* -------------------------------------------------------------------- */ + + +static char *match_string(char *ans, char *corr_ans, int n) +/* Searches for s (w/ surrounding whitespace removed) inside ans */ +/* looking at only n characters of s */ +{ + char *s; + char *corr; + int i; + + s = rstrdup(corr_ans); + for (i = n - 1; i > 0 && isspace(s[i]); i--); /* Kill trailing whitespace */ + s[i + 1] = 0; + for (i = 0; s[i] != 0; i++) s[i] = tolower(s[i]); + for (i = 0; isspace(s[i]); i++); /* Kill leading whitespace */ + corr = strstr(ans, s + i); + rfree(s); + return corr; +} + + +static rbool check_answer(char *ans, long start, long size) +/* qnum has already been fixed to start from 0 */ +/* Master's edition answer checker. Master's edition answers can */ +/* be seperate by AND and OR characters. If there is one OR in the */ +/* answer, all ANDs will also be treated as ORs */ +/* Furthermore, AND-delimited strings must appear in the correct order */ +/* unless PURE_ANSWER is false */ +{ + char *corr, *corr2; /* Pointer into answer to match correct answers */ + int match_mode; /* 0=AND mode, 1=OR mode */ + descr_line *astr; /* Holds the answer string */ + int i; /* Index to line of astr we're on. */ + char *p, *q, *r; /* Used to break astr up into pieces and + loop over them */ + + astr = read_descr(start, size); + if (astr == NULL) { + if (!PURE_ERROR) + writeln("GAME ERROR: Empty answer field."); + return 1; + } + + match_mode = 0; + for (i = 0; astr[i] != NULL; i++) + if (strstr(astr[i], "OR") != NULL) { + match_mode = 1; + break; + } + + corr = ans; + for (i = 0; astr[i] != NULL; i++) { /* loop over all lines of the answer */ + p = astr[i]; + do { + q = strstr(p, "OR"); + r = strstr(p, "AND"); + if (q == NULL || (r != NULL && r < q)) q = r; + if (q == NULL) q = p + strlen(p); /* i.e. points at the concluding null */ + corr2 = match_string(corr, p, q - p); + if (corr2 == NULL && match_mode == 0) { + free_descr(astr); + return 0; + } + if (corr2 != NULL && match_mode == 1) { + free_descr(astr); + return 1; + } + if (PURE_ANSWER && match_mode == 0) corr = corr2; + if (*q == 'O') p = q + 2; + else if (*q == 'A') p = q + 3; + else assert(*q == 0); + } while (*q != 0); + } + free_descr(astr); + if (match_mode == 0) return 1; /* AND: Matched them all */ + else return 0; /* OR: Didn't find a single match */ +} + + +/* Does the answer in string ans match answer anum? */ +/* Warning: this changes and then rfrees ans */ +rbool match_answer(char *ans, int anum) { + char *corr; + rbool ans_corr; + + for (corr = ans; *corr != 0; corr++) + *corr = tolower(*corr); + if (answer != NULL) { + /* corr=strstr(ans,answer[anum]); */ + corr = match_string(ans, answer[anum], strlen(answer[anum])); + rfree(ans); + if (corr == NULL) return 0; + } else if (ans_ptr != NULL) { + ans_corr = check_answer(ans, ans_ptr[anum].start, ans_ptr[anum].size); + rfree(ans); + return ans_corr; + } else writeln("INT ERR: Invalid answer pointer."); + return 1; + +} + + +rbool ask_question(int qnum) +/* 1=got it right, 0=got it wrong */ +{ + char *ans; + + qnum--; + + /* Now actually ask the question and compare the answers */ + if (question != NULL) + writeln(question[qnum]); + else if (quest_ptr != NULL) + print_descr(quest_ptr[qnum], 1); + else { + writeln("INT ERR: Invalid question pointer"); + return 1; + } + ans = agt_readline(2); + return match_answer(ans, qnum); +} + + +/* -------------------------------------------------------------------- */ +/* Miscellaneous support routines */ +/* -------------------------------------------------------------------- */ + +long read_number(void) { + char *s, *err; + long n; + + n = 1; + do { + if (n != 1) gen_sysmsg(218, "Please enter a *number*. ", MSG_MAIN, NULL); + s = agt_readline(1); + n = strtol(s, &err, 10); + if (err == s) err = NULL; + rfree(s); + } while (err == NULL); + return n; +} + + + + +void runptr(int i, descr_ptr dp_[], const char *msg, int msgid, + parse_rec *nounrec, parse_rec *objrec) +/* Prints out description unless it doesn't exist, in which + case it prints out either system message #msgid or the message + contained in msg. */ +{ + if (dp_[i].size > 0) print_descr(dp_[i], 1); + else alt_sysmsg(msgid, msg, nounrec, objrec); +} + + + +/* Score modes: + S:Score, R:Room +=list '(out of..'), -=don't list at all. + 0-- S+ R+ + 1-- S+ R + 2-- S R+ + 3-- S R + 4-- S+ R- + 5-- S R- + 6-- S- R+ + 7-- S- R + 8-- S- R- and disable SCORE. + */ + + +void print_score(void) { + char s[80]; + int i, rmcnt, totroom; + + if (score_mode < 5) { + if (score_mode == 0 || score_mode == 1 || score_mode == 4) + sprintf(s, "Your score is %ld (out of %ld possible).", tscore, max_score); + else sprintf(s, "Your score is %ld.", tscore); + writeln(s); + } + + if (score_mode < 4 || score_mode == 6 || score_mode == 7) { + rmcnt = 0; + totroom = 0; + for (i = 0; i <= maxroom - first_room; i++) + if (!room[i].unused) { + if (room[i].seen) rmcnt++; + /* Should really compute this once at the beginning, but */ + /* I don't want to add yet another global variable, particulary */ + /* since this is only used here. */ + totroom++; + } + if (score_mode % 2 == 0) + sprintf(s, "You have visited %d locations (out of %d in the game)", rmcnt, + totroom); + else sprintf(s, "You have visited %d locations.", rmcnt); + writeln(s); + } +} + + +int normalize_time(int tnum) { /* Convert hhmm so mm<60 */ + int min, hr; + + min = tnum % 100; /* The minutes */ + hr = tnum / 100; /* The hours */ + hr += min / 60; + min = min % 60; + while (hr < 0) hr += 24; + hr = hr % 24; + return hr * 100 + min; +} + + +void add_time(int dt) { + int min, hr; + + min = curr_time % 100; /* The minutes */ + hr = curr_time / 100; /* The hours */ + if (aver == AGT183) min += dt; /* AGT 1.83 version */ + else { /* Normal version */ + min += dt % 100; + hr += dt / 100; + } + while (min < 0) { + min = min + 60; + hr++; + } + hr += min / 60; + min = min % 60; + while (hr < 0) hr += 24; + hr = hr % 24; + curr_time = hr * 100 + min; +} + + +void look_room(void) { + compute_seen(); + writeln(""); + if (islit()) { + if (room[loc].name != NULL && room[loc].name[0] != 0 && + (!PURE_ROOMTITLE)) { + agt_textcolor(-1); /* Emphasized text on */ + writestr(room[loc].name); + agt_textcolor(-2); + writeln(""); + } /* Emphasized text off */ + if (room_firstdesc && room[loc].initdesc != 0) + msgout(room[loc].initdesc, 1); + else if (room_ptr[loc].size > 0) + print_descr(room_ptr[loc], 1); + print_contents(loc + first_room, 1); + if (listexit_flag) + v_listexit(); + } else + sysmsg(room[loc].light == 1 ? 6 : 7, + "It is dark. $You$ can't see anything."); + room_firstdesc = 0; + do_look = 0; +} + + +static void run_autoverb(void) { + int v0; /* Will hold the verb number of the autoverb */ + int savevb; + integer saveactor, savedobj, saveiobj; + parse_rec *save_actor_rec, *save_dobj_rec, *save_iobj_rec; + word saveprep; + + + beforecmd = 1; + + /* This is the penalty for vb, actor, etc being global variables. */ + savevb = vb; + saveactor = actor; + savedobj = dobj; + saveprep = prep; + saveiobj = iobj; + save_actor_rec = copy_parserec(actor_rec); + save_dobj_rec = copy_parserec(dobj_rec); + save_iobj_rec = copy_parserec(iobj_rec); + + if (room[loc].autoverb != 0) { + v0 = verb_code(room[loc].autoverb); + (void)scan_metacommand(0, v0, 0, 0, 0, NULL); + } + free_all_parserec(); + vb = savevb; + actor = saveactor; + dobj = savedobj; + iobj = saveiobj; + actor_rec = save_actor_rec; + dobj_rec = save_dobj_rec; + iobj_rec = save_iobj_rec; + prep = saveprep; +} + + + +/* ------------------------------------------------------------------- */ +/* MAIN COMMAND EXECUTION ROUTINES-- */ +/* These routines handle the execution of player commands */ +/* Then they change the status line, update counters, etc. */ +/* ------------------------------------------------------------------- */ + +static void creat_initdesc(void) { + int i; + + creatloop(i) + if (creature[i].location == loc + first_room && + creature[i].initdesc != 0) { + msgout(creature[i].initdesc, 1); + creature[i].initdesc = 0; + } +} + +/* Print out picture names, remember to put intro before first one. */ +/* This should be called with s==NULL before and after: + before to reset it, after to put the trailing newline on. */ +void listpictname(const char *s) { + static rbool first_pict = 1; /* True until we output first picture */ + + if (s == NULL) { + if (!first_pict) writeln(""); /* Trailing newline */ + first_pict = 1; + return; + } + if (first_pict) { + writeln(""); /* Skip a line */ + sysmsg(219, " Illustrations:"); + first_pict = 0; + } + writestr(" "); + writestr(s); +} + + +void listpict(int obj) { + char *s; + + if (it_pict(obj) != 0) { + s = objname(obj); + listpictname(s); + rfree(s); + } +} + + +void list_viewable(void) +/* List pictures that can be viewed, if any */ +{ + int i; + + listpictname(NULL); + + if (room[loc].pict != 0) + listpictname("scene"); + contloop(i, 1) + listpict(i); + contloop(i, 1000) + listpict(i); + contloop(i, loc + first_room) + listpict(i); + + for (i = 0; i < maxpix; i++) + if (room[loc].PIX_bits & (1L << i)) + listpictname(dict[pix_name[i]]); + listpictname(NULL); +} + + + +void newroom(void) { + rbool save_do_look; + integer prevloc; + + do { + save_do_look = do_look; + if (do_look == 1) look_room(); + creat_initdesc(); + if (save_do_look == 1 && aver >= AGTME10) + list_viewable(); /* Print out picts that can be viewed here. */ + do_look = 0; + + prevloc = loc; + if (do_autoverb) { + do_autoverb = 0; + run_autoverb(); + } + + if (!room[loc].seen) { /* This only runs on the first turn */ + room[loc].seen = 1; + tscore += room[loc].points; + } + } while (prevloc != loc); /* Autoverb could move player */ +} + + +static int min_delta(void) { + return (aver == AGT183) ? 1 : 0 ; +} + + +void increment_turn(void) { + int i; + + compute_seen(); + + newlife_flag = 0; + + if (quitflag) return; + + newroom(); + + if (winflag || deadflag || endflag) return; + + if (was_metaverb) return; /* No time should pass during a metaverb. */ + + turncnt++; + /* Now increment the time counter */ + if (delta_time > 0) { + if (PURE_TIME) + add_time(agt_rand(min_delta(), delta_time)); + else /* if !PURE_TIME */ + add_time(delta_time); + } + + for (i = 0; i <= CNT_NUM; i++) + if (agt_counter[i] >= 0) ++agt_counter[i]; + creatloop(i) + if (creature[i].location == loc + first_room && creature[i].hostile && + creature[i].timethresh > 0) { + parse_rec tmpcreat; /* Used for creature messages */ + make_parserec(i + first_creat, &tmpcreat); + curr_creat_rec = &tmpcreat; + + if (++creature[i].timecounter >= creature[i].timethresh) { + /* Creature attacks */ + sysmsg(16, "$The_c$$c_name$ suddenly attacks $you_obj$!"); + sysmsg(creature[i].gender == 0 ? 17 : 18, + " $You$ try to defend $your$self, but $the_c$$c_name$ " + "kills $you_obj$ anyhow."); + deadflag = 1; + } else /* 'Angrier' messages */ + if (creature[i].timethresh > 0 && + creature[i].timecounter > creature[i].timethresh - 3) + sysmsg(15, "$The_c$$c_name$ seems to be getting angrier."); + } +} + + +/* Wrapper for increment_turn used by exec routines below. + This just checks to make sure we're not one of the 1.8x versions + (which call increment turn from elsewhere) */ +static void exec_increment_turn(void) { + if (PURE_AFTER) increment_turn(); +} + +static void end_turn(void) { + if (textbold) agt_textcolor(-2); + textbold = 0; + set_statline(); + + if (quitflag) return; + + if (notify_flag && !was_metaverb) { + if (old_score < tscore) + sysmsg(227, " [Your score just went up]"); + else if (old_score > tscore) + sysmsg(228, " [Your score just went down]"); + } + old_score = tscore; + +} + + + +static void set_pronoun(int item) { + if (item == 0) return; + switch (it_gender(item)) { + case 0: + if (it_plur(item)) + last_they = item; + last_it = item; /* Change: last_it will be set even if the + noun is plural */ + break; + case 1: + last_she = item; + break; + case 2: + last_he = item; + break; + } +} + + +/* True if the current noun is the last one in the list. */ +static rbool lastnoun(parse_rec *list) { + if (list->info == D_END) return 1; + list++; + while (list->info == D_AND) list++; + return (list->info == D_END); +} + + + + +static void runverbs(parse_rec *actor0, int vnum, + parse_rec *lnoun, word prep0, parse_rec *iobj0) +/* The zeros are postpended simply to avoid a name conflict */ +{ + parse_rec *currnoun; + + textbold = 0; + do_look = 0; + do_autoverb = 0; + was_metaverb = 0; + actor = actor0->obj; + actor_rec = copy_parserec(actor0); + vb = vnum; + dobj = lnoun[0].obj; + dobj_rec = copy_parserec(lnoun); + prep = prep0; + iobj = iobj0->obj; + iobj_rec = copy_parserec(iobj0); + set_pronoun(actor); /* Basically the last one that isn't 0 will stick */ + set_pronoun(iobj0->obj); + was_metaverb = 0; /* Most verbs are not metaverbs; assume this by default */ + start_of_turn = 1; + end_of_turn = 0; + + if (lnoun[0].info == D_END || lnoun[0].info == D_ALL) { + end_of_turn = 1; + exec_verb(); + if (doing_restore) { + free_all_parserec(); + return; + } + if (PURE_AND) exec_increment_turn(); + } else for (currnoun = lnoun; currnoun->info != D_END; currnoun++) + if (currnoun->info != D_AND) { + free_all_parserec(); + end_of_turn = lastnoun(currnoun); + actor = actor0->obj; + actor_rec = copy_parserec(actor0); + vb = vnum; + dobj = currnoun->obj; + dobj_rec = copy_parserec(currnoun); + iobj = iobj0->obj; + iobj_rec = copy_parserec(iobj0); + set_pronoun(dobj); + exec_verb(); + if (doing_restore) return; + if (PURE_AND) + exec_increment_turn(); + else + start_of_turn = 0; + if (quitflag || winflag || deadflag || endflag) + break; + } + assert(end_of_turn); + if (!PURE_AND) exec_increment_turn(); + end_turn(); + free_all_parserec(); +} + + +/* The following store values for use by AGAIN */ +/* (so AGAIN can be implemented just by executing runverbs w/ the saved + values) */ +static int save_vnum; +static word save_prep; +static parse_rec save_actor; +static parse_rec save_obj; +parse_rec *save_lnoun = NULL; + + + +void exec(parse_rec *actor_, int vnum, + parse_rec *lnoun, word prep_, parse_rec *iobj_) { + + cmd_saveable = 0; + pronoun_mode = !PURE_PROSUB; + + if (vnum == verb_code(ext_code[wagain]) && lnoun[0].info == D_END + && iobj_->info == D_END && + (actor_->info == D_END || actor_->obj == save_actor.obj)) + if (save_lnoun == NULL) { + rfree(lnoun); + sysmsg(186, + "You can't use AGAIN until you've entered at least one command."); + return; + } else { + memcpy(actor_, &save_actor, sizeof(parse_rec)); + vnum = save_vnum; + prep_ = save_prep; + memcpy(iobj_, &save_obj, sizeof(parse_rec)); + rfree(lnoun); + lnoun = save_lnoun; + save_lnoun = NULL; + } + else + realverb = input[vp]; + + + runverbs(actor_, vnum, lnoun, prep_, iobj_); + + if (cmd_saveable) { + if (save_lnoun != NULL) rfree(save_lnoun); + + memcpy(&save_actor, actor_, sizeof(parse_rec)); + save_vnum = vnum; + save_lnoun = lnoun; + lnoun = NULL; + save_prep = prep_; + memcpy(&save_obj, iobj_, sizeof(parse_rec)); + } else + rfree(lnoun); +} + +} // End of namespace AGT +} // End of namespace Glk |