io.c

/*
 * Rog-O-Matic
 * Automatically exploring the dungeons of doom.
 *
 * Copyright (C) 2008 by Anthony Molinaro
 * Copyright (C) 1985 by Appel, Jacobson, Hamey, and Mauldin.
 *
 * This file is part of Rog-O-Matic.
 *
 * Rog-O-Matic 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 3 of the License, or
 * (at your option) any later version.
 *
 * Rog-O-Matic 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 Rog-O-Matic.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * io.c:
 *
 * This file contains all of the functions which deal with the real world.
 */

#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <ctype.h>
#include <string.h>
#include <sys/ioctl.h>
#include <time.h>
#include <sys/wait.h>
#include <errno.h>
#include <signal.h>
#include <setjmp.h>

#include "have_strlcat.h"
#include "have_strlcpy.h"
#include "strl.h"
#include "modern_curses.h"
#include "types.h"
#include "config.h"
#include "globals.h"
#include "install.h"
#include "termtokens.h"
#include "getroguetoken.h"

#define ROGUE_SECONDS (4) /* seconds to wait for rogue to exit */

#define READ 0

/*
 * Charonscreen returns the current character on the screen (using
 * curses(3)).  This macro is based on the winch(win) macro.
 */
#define charonscreen(Y, X) (A_CHARTEXT & mvwinch(stdscr, Y, X))

/* static declarations */
static char *month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

static char screen00 = ' ';

/* Constants */

#define SENDQ 256

/* potion quaffing state */
enum p_state {
    p_unset = 0, /* no multi-message potion quaffing in progress */
    p_what = 1,	 /* "Quaff what? " seen */
    p_list = 2,	 /* "(* for list): " seen */
    p_more = 3,	 /* "--More--" seen */
    p_call = 4,	 /* "Call it: " seen */
    p_quest = 5, /* sent "?" reply to set proper name */
};
static enum p_state potion_state = p_unset;

/* scroll reading state */
enum s_state {
    s_unset = 0, /* no multi-message scroll reading in progress */
    s_what = 1,	 /* "Read what? " seen */
    s_list = 2,	 /* "(* for list): " seen */
    s_more = 3,	 /* "--More--" seen */
    s_call = 4,	 /* "Call it: " seen */
    s_quest = 5, /* sent "?" reply to set proper name */
};
static enum s_state scroll_state = s_unset;

/* The command queue */

static char queue[SENDQ]; /* stuff to be sent to Rogue */

static int s_row1 = -100; /* start scroll regions way out of bounds */
static int s_row2 = 100;  /* start scroll regions way out of bounds */

static void scrollup(void);
static void scrolldown(void);
static void printscreen(void);
static void sendcnow(char c);
static int pending(void);
static void deadrogue(void);
static void waitforspace(void);
static char **helpline;
static void putn(char c, FILE *f, int n);

static void waitforspace(void);
static void sendcnow(char c);

static void
scrollup(void)
{
    int r;
    int c;

    newdoors = doorlist;

    for (r = s_row1; r < s_row2; r++) {
	for (c = 0; c < C; c++) {
	    if (valrc(r, c) && valrc(r + 1, c)) {
		screen[r][c] = screen[r + 1][c];
		updatepos(screen[r][c], r, c);
	    }
	}
    }

    for (c = 0; c < C; c++) {
	if (valrc(s_row2, c)) {
	    screen[s_row2][c] = ' ';
	    updatepos(screen[s_row2][c], s_row2, c);
	}
    }
}

static void
scrolldown(void)
{
    int r;
    int c;

    for (r = s_row2; r > s_row1; r--) {
	for (c = 0; c < C; c++) {
	    if (valrc(r, c) && valrc(r - 1, c)) {
		screen[r][c] = screen[r - 1][c];
		updatepos(screen[r][c], r, c);
	    }
	}
    }

    for (c = 0; c < C; c++) {
	if (valrc(s_row1, c)) {
	    screen[s_row1][c] = ' ';
	    updatepos(screen[s_row1][c], s_row1, c);
	}
    }
}

static void
printscreen(void)
{
    int i, j;

    /* firewall */
    if (!valrc(row, col)) {
	return;
    }

    debuglog("-- cursor  [%2d, %2d] [%c] [%3d] -------------------------------------------------\n", row, col, screen[row][col],
	     screen[row][col]);
    debuglog("             1111111111222222222233333333334444444444555555555566666666667777777777\n");
    debuglog("   01234567890123456789012345678901234567890123456789012345678901234567890123456789\n");

    for (i = 0; i < R; ++i) {
	debuglog("%02d", i);

	if (i >= s_row1 && i <= s_row2) {
	    debuglog("*");
	} else {
	    debuglog(" ");
	}

	for (j = 0; j < C; ++j) {
	    if (i == row && j == col) {
		debuglog("_");
	    } else if (valrc(i, j)) {
		debuglog("%c", screen[i][j]);
	    }
	}

	debuglog("\n");
    }

    debuglog("--------------------------------------------------------------------------------\n");
}

static const char *
p_state_name(enum p_state state)
{
    switch (state) {
    case p_unset:
	return "p_unset";
    case p_what:
	return "p_what";
    case p_list:
	return "p_list";
    case p_more:
	return "p_more";
    case p_call:
	return "p_call";
    case p_quest:
	return "p_quest";
    default:
	break;
    }
    return "p_unknown";
}

static const char *
s_state_name(enum s_state state)
{
    switch (state) {
    case s_unset:
	return "s_unset";
    case s_what:
	return "s_what";
    case s_list:
	return "s_list";
    case s_more:
	return "s_more";
    case s_call:
	return "s_call";
    case s_quest:
	return "s_quest";
    default:
	break;
    }
    return "s_unknown";
}

/*
 * Getrogue: Sensory interface.
 *
 * Handle grungy low level terminal I/O. Getrogue reads tokens from the
 * Rogue process and interprets them, making the screen array an image of
 * the rogue level. Getrogue returns when the string waitstr has been read
 * and either the cursor is on the Rogue '@' or some other condition
 * implies that we have synchronized with Rogue.
 */

/* waitstr - String to synchronize with */
/*
 * onat - 0 ==> Wait for waitstr,
 *	  1 ==> Cursor on @ sufficient,
 *	  2 ==> [1] + send ';' when ever we eat a --More-- message
 */
void
getrogue(char *waitstr, int onat)
{
    char ch;			       /* rogue output character, or screen reading package token */
    char *quaff_what = "Quaff what? "; /* FSM to check for "Quaff what? " */
    char *read_what = "Read what? ";   /* FSM to check for "Read what? " */
    char *call_it = "Call it: ";       /* FSM to check for "Call it: " */
    char *more = "--More--";	       /* FSM to check for "--More--' */
    char *for_list = "(* for list): "; /* FSM to check for "(* for list): " prompt */
    char *tombstone_grass = ")______"; /* FSM to check for ")______" (tombstone grass) */
    char *wait_msg = waitstr;	       /* FSM to check for the wait msg */

    bool botprinted = false;
    int jump_ret; /* sigsetjmp return value */
    int wasmapped = didreadmap;
    int *doors;
    static bool moved = false;
    static int jump_count = 0; /* number of non-local jumps */
    int r;
    int c;
    int i, j;

    /* firewall */
    if (!valrc(row, col)) {
	return;
    }

    newdoors = doorlist; /* no new doors found yet */
    atrow0 = atrow;	 /* Save our current position */
    atcol0 = atcol;	 /* Save our current position */

    if (moved) {	/* If we moved last time, put any */
	sleepmonster(); /* Old monsters to sleep */
	moved = false;
    }

    /* debugging info */
    if debug (D_MESSAGE) {
	at(28, 0);
	clrtoeol();
	at(27, 0);
	clrtoeol();
	printw("getrogue: waitstr ->%s<-  onat %d.", waitstr, onat);
	at(row, col);
	if (!quiet) {
	    refresh();
	}
    }

    /* While we have not reached the end of the Rogue input, read */
    /* characters from Rogue and figure out what they mean.       */
    while ((*wait_msg) || ((!hasted || version != RV36A) && onat && screen[row][col] != '@')) {

	/*
	 * jmp_point for the SIGALRM timer timeout if needed
	 */
	if (is_timer_active()) {

	    /* establish the jmp_point for the SIGALRM timer timeout */
	    jump_ret = sigsetjmp(jmp_point, 1);

	    /*
	     * case: this is our first time here, note jmp_point is now ready
	     */
	    if (jump_ret == 0) {
		jmp_point_ready = true;

		/*
		 * case: note non-local jump
		 */
	    } else {

		/* report non-local jump */
		++jump_count; /* HINT: breakpoint here to catch a timer timeout */
		debuglog("SIGALRM: timer timeout jump number: %d\n", jump_count);

		/* try to reset the state */
		scroll_state = s_unset;
		potion_state = p_unset;
		quaff_what = "Quaff what? ";
		read_what = "Read what? ";
		for_list = "(* for list): ";

		/* clear old commands in the send queue */
		clearsendqueue();

		/* compel rogue to redraw the screen */
		if (version < RV53A) {
		    sendnow("%c;%c//;", ESC, ctrl('l'));
		} else {
		    sendnow("%c;%c;", ESC, ctrl('r'));
		}

		/* try to restore the screen to some sane state */
		at(R, 0);
		clrtoeol();
		printw("timeout!");
		if (!quiet) {
		    refresh();
		}
	    }
	}

	/*
	 * get next rogue output character, or screen reading package token
	 */
	set_alarm(); /* in case we hang reading from rogue, set a timeout timer */
	ch = getroguetoken();
	if (debug(D_MESSAGE)) {
	    at(28, col);
	    printw("%s", unctrl(ch));
	    at(row, col);
	    if (!quiet) {
		refresh();
	    }
	}
	clear_alarm(); /* we did not hang, cancel the timeout timer */

	/*
	 * Tokens used by the screen reading package are NOT processed
	 * for matching against various messages.  This is in case
	 * the ncurses system generates such token, such as a clear
	 * screen, or such as a cursor movement while rogue is
	 * printing a message.
	 */
	if (!is_token(ch)) {

	    /*
	     * If message ends in "Quaff what? ", note it
	     */
	    if (ch == *quaff_what) {
		++quaff_what;
		if (*quaff_what == '\0') {

		    /*
		     * force the scroll reading state to be unset
		     */
		    if (scroll_state != s_unset) {
			debuglog("%s: file: %s line: %d scroll_state: %s ==> s_unset saw: \"Quaff what? \"\n", __func__, __FILE__,
				 __LINE__, s_state_name(scroll_state));
			scroll_state = s_unset;
		    }

		    /*
		     * start the potion quaffing state
		     */
		    debuglog("%s: file: %s line: %d potion_state: %s ==> p_what saw: \"Quaff what? \"\n", __func__, __FILE__,
			     __LINE__, p_state_name(potion_state));
		    potion_state = p_what;
		}
	    } else {
		quaff_what = "Quaff what? ";
	    }

	    /*
	     * If message ends in "Read what? ", note it
	     */
	    if (ch == *read_what) {
		++read_what;
		if (*read_what == '\0') {

		    /*
		     * force the potion quaffing state to be unset
		     */
		    if (potion_state != p_unset) {
			debuglog("%s: file: %s line: %d potion_state: %s ==> p_unset saw: \"Read what? \"\n", __func__, __FILE__,
				 __LINE__, p_state_name(potion_state));
			potion_state = p_unset;
		    }

		    /*
		     * start the scroll reading state
		     */
		    debuglog("%s: file: %s line: %d scroll_state: %s ==> s_what saw: \"Read what? \"\n", __func__, __FILE__,
			     __LINE__, s_state_name(scroll_state));
		    scroll_state = s_what;
		}
	    } else {
		read_what = "Read what? ";
	    }

	    /*
	     * If message ends in "(* for list): ", call terpmes()
	     */
	    if (ch == *for_list) {
		++for_list;
		if (*for_list == '\0') {

		    /*
		     * advance the potion quaffing state if it was p_what
		     */
		    if (potion_state == p_what) {

			/*
			 * force the scroll reading state to be unset
			 */
			if (scroll_state != s_unset) {
			    debuglog("%s: file: %s line: %d scroll_state: %s ==> s_unset saw: \"(* for list) \"\n", __func__,
				     __FILE__, __LINE__, s_state_name(scroll_state));
			    scroll_state = s_unset;
			}

			/*
			 * advance potion quaff state
			 */
			potion_state = p_list;
			debuglog("%s: file: %s line: %d potion_state: p_what ==> %s saw: \"(* for list) \"\n", __func__, __FILE__,
				 __LINE__, p_state_name(potion_state));

			/*
			 * advance the scroll reading state if it was s_what
			 */
		    } else if (scroll_state == s_what) {

			/*
			 * force the potion quaffing state to be unset
			 */
			if (potion_state != p_unset) {
			    debuglog("%s: file: %s line: %d potion_state: %s ==> p_unset saw: \"(* for list) \"\n", __func__,
				     __FILE__, __LINE__, p_state_name(potion_state));
			    potion_state = p_unset;
			}

			/*
			 * advance scroll reading state
			 */
			scroll_state = s_list;
			debuglog("%s: file: %s line: %d scroll_state: s_what ==> %s saw: \"(* for list) \"\n", __func__, __FILE__,
				 __LINE__, s_state_name(scroll_state));

			/*
			 * otherwise force the scroll reading, and force the potion quaffing state to be unset
			 */
		    } else {

			/*
			 * force the scroll reading state to be unset
			 */
			if (scroll_state != s_unset) {
			    debuglog("%s: file: %s line: %d scroll_state: %s ==> s_unset saw: \"(* for list) \"\n", __func__,
				     __FILE__, __LINE__, s_state_name(scroll_state));
			    scroll_state = s_unset;
			}

			/*
			 * force the potion quaffing state to be unset
			 */
			if (potion_state != p_unset) {
			    debuglog("%s: file: %s line: %d potion_state: %s ==> p_unset saw: \"(* for list) \"\n", __func__,
				     __FILE__, __LINE__, p_state_name(potion_state));
			    potion_state = p_unset;
			}
		    }

		    /*
		     * parse top line message from rogue
		     */
		    terpmes();
		}
	    } else {
		for_list = "(* for list): ";
	    }

	    /*
	     * If the message has a "--More--", strip it off and call terpmes()
	     */
	    if (ch == *more) {
		++more;
		if (*more == '\0') {

		    /*
		     * advance the potion quaffing state if it was p_list
		     */
		    if (potion_state == p_list) {

			/*
			 * force the scroll reading state to be unset
			 */
			if (scroll_state != s_unset) {
			    debuglog("%s: file: %s line: %d scroll_state: %s ==> s_unset saw: \"--More--\"\n", __func__, __FILE__,
				     __LINE__, s_state_name(scroll_state));
			    scroll_state = s_unset;
			}

			/*
			 * advance potion quaff state
			 */
			potion_state = p_more;
			debuglog("%s: file: %s line: %d potion_state: p_list ==> %s saw: \"--More--\"\n", __func__, __FILE__,
				 __LINE__, p_state_name(potion_state));

			/*
			 * advance the scroll reading state if it was s_list
			 */
		    } else if (scroll_state == s_list) {

			/*
			 * force the potion quaffing state to be unset
			 */
			if (potion_state != p_unset) {
			    debuglog("%s: file: %s line: %d potion_state: %s ==> p_unset saw: \"--More--\"\n", __func__, __FILE__,
				     __LINE__, p_state_name(potion_state));
			    potion_state = p_unset;
			}

			/*
			 * advance scroll reading state
			 */
			scroll_state = s_more;
			debuglog("%s: file: %s line: %d scroll_state: s_list ==> %s saw: \"--More--\"\n", __func__, __FILE__,
				 __LINE__, s_state_name(scroll_state));

			/*
			 * otherwise force the scroll reading, and force the potion quaffing state to be unset
			 */
		    } else {

			/*
			 * force the scroll reading state to be unset
			 */
			if (scroll_state != s_unset) {
			    debuglog("%s: file: %s line: %d scroll_state: %s ==> s_unset saw: \"--More--\"\n", __func__, __FILE__,
				     __LINE__, s_state_name(scroll_state));
			    scroll_state = s_unset;
			}

			/*
			 * force the potion quaffing state to be unset
			 */
			if (potion_state != p_unset) {
			    debuglog("%s: file: %s line: %d potion_state: %s ==> p_unset saw: \"--More--\"\n", __func__, __FILE__,
				     __LINE__, p_state_name(potion_state));
			    potion_state = p_unset;
			}
		    }

		    /* More than 50 messages since last command ==> start logging */
		    ++morecount;
		    if (morecount > 50 && !logging) {
			toggleecho();
			dwait(D_WARNING, __func__, "Started logging --More-- loop");
		    }

		    /* Send a space (and possibly a semicolon) to clear the message */
		    if (onat == 2) {
			if (version >= RV54B && potion_state == p_more) {
			    sendnow(" ");
			} else {
			    sendnow(" ;");
			}
		    } else {
			sendnow(" ");
		    }

		    /* Clear the "--More--" of the end of the message */
		    for (i = col - 7; i < col; ++i) {
			if (valrc(0, i)) {
			    screen[0][i] = ' ';
			}
		    }

		    terpmes(); /* Interpret the message */
		}
	    } else {
		more = "--More--";
	    }

	    /*
	     * If the message is "Call it: ", clear or process the call it the request
	     */
	    if (ch == *call_it) {
		++call_it;
		if (*call_it == '\0') {

		    /*
		     * advance the potion quaffing state if it was p_more
		     */
		    if (potion_state == p_list || potion_state == p_more) {

			/*
			 * force the scroll reading state to be unset
			 */
			if (scroll_state != s_unset) {
			    debuglog("%s: file: %s line: %d scroll_state: %s ==> s_unset saw: \"Call it: \"\n", __func__, __FILE__,
				     __LINE__, s_state_name(scroll_state));
			    scroll_state = s_unset;
			}

			/*
			 * advance potion quaff state
			 */
			if (potion_state == p_list) {
			    potion_state = p_call;
			    debuglog("%s: file: %s line: %d potion_state: p_list ==> %s saw: \"Call it: \"\n", __func__, __FILE__,
				     __LINE__, p_state_name(potion_state));
			} else if (potion_state == p_more) {
			    potion_state = p_call;
			    debuglog("%s: file: %s line: %d potion_state: p_more ==> %s saw: \"Call it: \"\n", __func__, __FILE__,
				     __LINE__, p_state_name(potion_state));
			}

			/*
			 * advance the scroll reading state if it was s_more
			 */
		    } else if (scroll_state == s_list || scroll_state == s_more) {

			/*
			 * force the potion quaffing state to be unset
			 */
			if (potion_state != p_unset) {
			    debuglog("%s: file: %s line: %d potion_state: %s ==> p_unset saw: \"Call it: \"\n", __func__, __FILE__,
				     __LINE__, p_state_name(potion_state));
			    potion_state = p_unset;
			}

			/*
			 * advance scroll reading state
			 */
			if (scroll_state == s_list) {
			    scroll_state = s_call;
			    debuglog("%s: file: %s line: %d scroll_state: s_list ==> %s saw: \"Call it: \"\n", __func__, __FILE__,
				     __LINE__, s_state_name(scroll_state));
			} else if (scroll_state == s_more) {
			    scroll_state = s_call;
			    debuglog("%s: file: %s line: %d scroll_state: s_more ==> %s saw: \"Call it: \"\n", __func__, __FILE__,
				     __LINE__, s_state_name(scroll_state));
			}

			/*
			 * otherwise force the scroll reading, and force the potion quaffing state to be unset
			 */
		    } else {

			/*
			 * force the scroll reading state to be unset
			 */
			if (scroll_state != s_unset) {
			    debuglog("%s: file: %s line: %d scroll_state: %s ==> s_unset saw: \"Call it: \"\n", __func__, __FILE__,
				     __LINE__, s_state_name(scroll_state));
			    scroll_state = s_unset;
			}

			/*
			 * force the potion quaffing state to be unset
			 */
			if (potion_state != p_unset) {
			    debuglog("%s: file: %s line: %d potion_state: %s ==> p_unset saw: \"Call it: \"\n", __func__, __FILE__,
				     __LINE__, p_state_name(potion_state));
			    potion_state = p_unset;
			}
		    }

		    /*
		     * process a "Call it: " message
		     */
		    if (onat == 2) {

			/*
			 * advance the potion quaffing state
			 */
			if (version >= RV54B) {

			    if (potion_state == p_call) {

				/*
				 * advance potion quaffing state to p_quest
				 */
				potion_state = p_quest;
				debuglog("%s: file: %s line: %d potion_state: p_call ==> %s saw: \"Call it: \"\n", __func__,
					 __FILE__, __LINE__, p_state_name(potion_state));

				/* since rogue 5.4.5, calling something ? sets the proper name be set automatically */
				debuglog("%s: file: %s line: %d sending: \"?{nl};\"\n", __func__, __FILE__, __LINE__);
				sendnow("?\n;");

				/*
				 * advance the scroll reading state
				 */
			    } else if (scroll_state == s_call) {

				/*
				 * advance scroll reading state to s_quest
				 */
				scroll_state = s_quest;
				debuglog("%s: file: %s line: %d scroll_state: s_call ==> %s saw: \"Call it: \"\n", __func__,
					 __FILE__, __LINE__, s_state_name(scroll_state));

				/* since rogue 5.4.5, calling something ? sets the proper name be set automatically */
				debuglog("%s: file: %s line: %d sending: \"?{nl};\"\n", __func__, __FILE__, __LINE__);
				sendnow("?\n;");
			    }
			}

			/* Send an escape and semicolon to clear the message */
			debuglog("%s: file: %s line: %d sending: \"ESC;\"\n", __func__, __FILE__, __LINE__);
			sendnow("%c;", ESC);

		    } else {

			/* Send an escape to clear the message */
			debuglog("%s: file: %s line: %d sending: \"ESC\"\n", __func__, __FILE__, __LINE__);
			sendnow("%c", ESC);
		    }
		}
	    } else {
		call_it = "Call it: ";
	    }

	    /*
	     * Rogomatic now keys off of the grass under the Tombstone to
	     * detect that it has been killed. This was done because the
	     * "Press return" prompt only happens if there is a score file
	     * Available on that system. Hopefully the grass is the same
	     * in all versions of Rogue!
	     */
	    if (ch == *tombstone_grass) {
		++tombstone_grass;
		if (*tombstone_grass == '\0') {
		    debuglog("%s: file: %s line: %d saw: \")_______\"\n", __func__, __FILE__, __LINE__);
		    addch(ch);
		    debuglog("%s: file: %s line: %d calling: deadrogue()\n", __func__, __FILE__, __LINE__);
		    deadrogue();
		    return;
		}
	    } else {
		tombstone_grass = ")_______";
	    }

	    /*
	     * Check to see whether we have read the synchronization string
	     */
	    if (*wait_msg) {
		if (ch == *wait_msg) {
		    wait_msg++;
		} else {
		    wait_msg = waitstr;
		}
	    }
	}

	/* Now figure out what the token means */
	switch (ch) {
	case BS_TOK:
	    col--;
	    debuglog("BS_TOK      [%2d, %2d] [%c]\n", row, col, screen[row][col]);
	    break;

	case CB_TOK:
	    for (i = 0; i < col; i++) {
		updatepos(' ', row, i);
		screen[row][i] = ' ';
	    }

	    debuglog("CB_TOK      [%2d, %2d] [%c]\n", row, col, screen[row][col]);
	    break;

	case CE_TOK:
	    if (row && row < R - 1) {
		for (i = col; i < C; i++) {
		    updatepos(' ', row, i);
		    screen[row][i] = ' ';
		}
	    } else {
		for (i = col; i < C; i++) {
		    screen[row][i] = ' ';
		}
	    }

	    if (row) {
		at(row, col);
		clrtoeol();
	    } else if (col == 0) {
		screen00 = ' ';
	    }

	    debuglog("CE_TOK      [%2d, %2d] [%c]\n", row, col, screen[row][col]);
	    break;

	case CH_TOK:
	    debuglog("CH_TOK [%d, %d] [%d, %d]\n", number1, number2, row, col);
	    s_row1 = number1 - 1;
	    s_row2 = number2 - 1;
	    debuglog("CH_TOK scroll region %d - %d\n", s_row1, s_row2);
	    break;

	case CL_TOK:
	    clearscreen();
	    row = 0;
	    col = 0;
	    debuglog("CL_TOK [%d, %d]\n", row, col);
	    break;

	case CM_TOK:
	    screen00 = screen[0][0];
	    row = number1 - 1;
	    col = number2 - 1;
	    debuglog("CM_TOK      [%2d, %2d] [%c]\n", row, col, screen[row][col]);
	    break;

	case CR_TOK:
	    /* Handle missing '--more--' between inventories  MLM 24-Jun-83 */
	    /* --more-- doesn't seem too be missing anymore NYM 3/29/08
	     * if (row==0 && screen[0][1]==')' && screen[0][col-1] != '-')
	     *   terpmes ();
	     */
	    col = 0;
	    debuglog("CR_TOK      [%2d, %2d] [%c]\n", row, col, screen[row][col]);
	    break;

	case ER_TOK:
	    break;

	case LF_TOK:
	    row++;
	    debuglog("LF_TOK      check for scroll %d > %d\n", row, s_row2);

	    if (row > s_row2) {
		debuglog("LF_TOK      scroll up\n");
		scrollup();
	    }

	    debuglog("LF_TOK      [%2d, %2d] [%c]\n", row, col, screen[row][col]);
	    break;

	case ND_TOK:
	    row += number1;
	    debuglog("ND_TOK [%2d] [%2d, %2d] [%c]\n", number1, row, col, screen[row][col]);
	    break;

	case SE_TOK:
	    debuglog("SE_TOK\n");
	    revvideo = false;
	    standend();
	    break;

	case SO_TOK:
	    debuglog("SO_TOK\n");
	    revvideo = true;
	    standout();
	    break;

	case TA_TOK:
	    col = 8 * (1 + col / 8);
	    debuglog("TA_TOK      [%2d, %2d] [%c]\n", row, col, screen[row][col]);
	    break;

	case EOF:
	    if (interrupted) {
		return;
	    }

	    if (!replaying || !logdigested) {
		playing = false;
		return;
	    }

	    saynow("End of rogomatic game log, type 'Q' to exit.");
	    return;
	    break;

	case UP_TOK:
	    row--;
	    debuglog("UP_TOK      [%2d, %2d] [%c]\n", row, col, screen[row][col]);
	    break;

	case HM_TOK:
	    col = 0;
	    row = 0;
	    debuglog("HM_TOK      [%2d, %2d] [%c]\n", row, col, screen[row][col]);
	    break;

	case NU_TOK:
	    row -= number1;
	    debuglog("NU_TOK [%2d] [%2d, %2d] [%c]\n", number1, row, col, screen[row][col]);
	    break;

	case NR_TOK:
	    col += number1;
	    debuglog("NR_TOK [%2d] [%2d, %2d] [%c]\n", number1, row, col, screen[row][col]);
	    break;

	case NL_TOK:
	    debuglog("NL_TOK\n");
	    col -= number1;
	    debuglog("NL_TOK [%2d] [%2d, %2d] [%c]\n", number1, row, col, screen[row][col]);
	    break;

	case SC_TOK:
	    debuglog("SC_TOK      [%2d, %2d]\n", row, col);
	    break;

	case RC_TOK:
	    debuglog("RC_TOK      [%2d, %2d]\n", row, col);
	    break;

	case SR_TOK:
	    debuglog("SR_TOK      [%2d, %2d]\n", row, col);
	    scrolldown();
	    break;

	default:
	    if (ch < ' ') {
		waitforspace();
	    } else if (row) {
		at(row, col);

		if (!emacs && !terse) {
		    addch(ch);
		}

		if (row == R - 1) {
		    botprinted = true;
		} else {
		    updatepos(ch, row, col);
		}
	    } else if (col == 0) {
		screen00 = screen[0][0];
	    } else if (col == 1 && ch == 'l' && screen[0][0] == 'I') {
		screen[0][0] = screen00;

		if (screen00 != ' ') {
		    terpmes();
		}

		screen[0][0] = 'I';
	    }

	    screen[row][col++] = ch;
	    debuglog("OTHER   [%c] [%2d, %2d] [%c]\n", ch, row, (col - 1), screen[row][col - 1]);
	    break;
	}
    }

    if (botprinted) {
	terpbot();
    }

    if (atrow != atrow0 || atcol != atcol0) {
	updateat();	    /* Changed position, record the move */
	moved = true;	    /* Indicate that we moved */
	wakemonster(8);	    /* Wake up adjacent mean monsters */
	currentrectangle(); /* Keep current rectangle up to date.   LGCH */
    }

    if (!usesynch && !pending()) {
	usesynch = true;
	lastobj = NONE;
	resetinv();
    }

    if (version < RV53A && checkrange && !pending()) {
	command(T_OTHER, "Iz");
	checkrange = false;
    }

    /* If mapping status has changed */
    if (wasmapped != didreadmap) {
	dwait(D_CONTROL | D_SEARCH, __func__, "wasmapped: %d != didreadmap: %d", wasmapped, didreadmap);

	mapinfer();
    }

    if (didreadmap != Level) {
	doors = doorlist;

	while (doors != newdoors) {
	    r = *doors++;
	    c = *doors++;
	    dwait(D_INFORM, __func__, "new door at (%d,%d)", r, c);
	    inferhall(r, c);
	}
    }

    if (!blinded) {
	for (i = atrow - 1; i <= atrow + 1; i++) {			    /* For blanks around the  */
	    for (j = atcol - 1; j <= atcol + 1; j++) {			    /* rogue...               */
		if (valrc(i, j) && seerc(' ', i, j) && onrc(CANGO, i, j)) { /* CANGO+BLANK impossible */
		    unsetrc(CANGO | SAFE, i, j);			    /* Infer cant go and...   */
		    setnewgoal();					    /* invalidate the map.    */
		}
	    }
	}
    }

    at(row, col);

    if (!emacs && !terse && !quiet) {
	refresh();
    }

    printscreen();
    return;
}

/*
 * terpbot: Read the Rogue status line and set the various status
 * variables. This routine depends on the value of version to decide what
 * the status line looks like.
 */

void
terpbot(void)
{
    char sstr[MU_BUF + 1];     /* scanned string, +1 for paranoia */
    char modeline[SM_BUF + 1]; /* mode line, +1 for paranoia */
    int oldlev = Level, oldgold = Gold, oldhp = Hp, Str18 = 0;
    extern int geneid;
    int i, oldstr = Str, oldAc = Ac, oldExp = Explev;

    /* zeroize arrays */
    memset(sstr, 0, sizeof(sstr));	   /* paranoia */
    memset(modeline, 0, sizeof(modeline)); /* paranoia */

    /* Since we use scanf to read this field, it must not be left blank */
    if (screen[R - 1][C - 2] == ' ') {
	screen[R - 1][C - 2] = 'X';
    }

    /* Read the bottom line, there are three versions of the status line */
    if (version < RV52A) { /* Rogue 3.6, Rogue 4.7? */
	sscanf(screen[R - 1], " Level: %d Gold: %d Hp: %d(%d) Str: %s Ac: %d Exp: %d/%d %s", &Level, &Gold, &Hp, &Hpmax, sstr, &Ac,
	       &Explev, &Exp, Ms);
	sscanf(sstr, "%d/%d", &Str, &Str18);
	Str = Str * 100 + Str18;

	if (Str > Strmax) {
	    Strmax = Str;
	}
    } else if (version < RV53A) { /* Rogue 5.2 (versions A and B) */
	sscanf(screen[R - 1], " Level: %d Gold: %d Hp: %d(%d) Str: %d(%d) Ac: %d Exp: %d/%d %s", &Level, &Gold, &Hp, &Hpmax, &Str,
	       &Strmax, &Ac, &Explev, &Exp, Ms);

	Str = Str * 100;
	Strmax = Strmax * 100;
    } else { /* Rogue 5.3 (and beyond???) */
	sscanf(screen[R - 1], " Level: %d Gold: %d Hp: %d(%d) Str: %d(%d) Arm: %d Exp: %d/%d %s", &Level, &Gold, &Hp, &Hpmax, &Str,
	       &Strmax, &Ac, &Explev, &Exp, Ms);

	Str = Str * 100;
	Strmax = Strmax * 100;
	Ac = 10 - Ac;
    }

    /* Monitor changes in some variables */
    if (screen[R - 1][C - 2] == 'X') {
	screen[R - 1][C - 2] = ' '; /* Restore blank */
    }

    if (oldlev != Level) {
	newlevel();
    }

    if (Level > MaxLevel) {
	MaxLevel = Level;
    }

    if (oldgold < Gold) {
	deletestuff(atrow, atcol);
    }

    if (oldhp < Hp) {
	newring = true;
    }

    lastdamage = max(0, oldhp - Hp);

    /*
     * Insert code here to monitor changes in attributes due to special
     * attacks					MLM October 26, 1983.
     */

    setbonuses();

    /*
     * If in special output modes, generate output line
     */

    if ((oldlev != Level || oldgold != Gold || oldstr != Str || oldAc != Ac || oldExp != Explev)) {
	/* Stuff the new values into the argument space (for ps command) */
	snprintf(modeline, SM_BUF, "Rgm %d: Id%d L%d %d %d(%d) s%d a%d e%d    ", rogpid, geneid, Level, Gold, Hp, Hpmax, Str / 100,
		 10 - Ac, Explev);

	/* Handle Emacs and Terse mode */
	if (emacs || terse) {
	    /* Skip backward over blanks and nulls */
	    for (i = C - 1; (i >= 0) && (screen[R - 1][i] == ' ' || screen[R - 1][i] == '\0'); i--)
		;
	    if (i < C - 1) {
		screen[R - 1][i + 1] = '\0';
	    }
	    screen[R - 1][C] = '\0'; /* paranoia */

	    if (emacs) {
		snprintf(modeline, SM_BUF, " %s (%%b)", screen[R - 1]);

		if (strlen(modeline) > C - 8) {
		    snprintf(modeline, SM_BUF, " %s", screen[R - 1]);
		}

		if (!quiet) {
		    fprintf(realstdout, "%s", modeline);
		    fflush(realstdout);
		}
	    } else if (terse && oldlev != Level && !quiet) {
		fprintf(realstdout, "%s\n", screen[R - 1]);
		fflush(realstdout);
	    }
	}
    }
}

/*
 * dumpwalls: Dump the current screen map
 */

void
dumpwalls(void)
{
    int r, c, S;
    char ch;

    printexplored();

    for (r = 1; r < R - 1; r++) {
	for (c = 0; c < C; c++) {
	    if (valrc(r, c)) {
		S = scrmap[r][c];
		ch = (ARROW & S)				    ? 'a'
		     : (TELTRAP & S)				    ? 't'
		     : (TRAPDOR & S)				    ? 'v'
		     : (GASTRAP & S)				    ? 'g'
		     : (BEARTRP & S)				    ? 'b'
		     : (DARTRAP & S)				    ? 's'
		     : (WATERAP & S)				    ? 'w'
		     : (TRAP & S)				    ? '^'
		     : (STAIRS & S)				    ? '>'
		     : (RUNOK & S)				    ? '%'
		     : (((DOOR + BEEN) & S) == DOOR + BEEN)	    ? 'D'
		     : (DOOR & S)				    ? 'd'
		     : (((BOUNDARY + BEEN) & S) == BOUNDARY + BEEN) ? 'B'
		     : (((ROOM + BEEN) & S) == ROOM + BEEN)	    ? 'R'
		     : (BEEN & S)				    ? ':'
		     : (HALL & S)				    ? '#'
		     : (((BOUNDARY + WALL) & S) == BOUNDARY + WALL) ? 'W'
		     : (BOUNDARY & S)				    ? 'b'
		     : (ROOM & S)				    ? 'r'
		     : (CANGO & S)				    ? '.'
		     : (WALL & S)				    ? 'W'
		     : (S)					    ? 'X'
								    : '\0';

		if (ch) {
		    mvaddch(r, c, ch);
		}
	    }
	}
    }

    if (valrc(row, col)) {
	at(row, col);
    }
}

/*
 * sendnow: Send a string to the Rogue process.
 */

void
sendnow(char *f, ...)
{
    char cmd[MU_BUF + 1]; /* command string, +1 for paranoia */
    char *s = cmd;
    va_list ap;

    /* zeroize arrays */
    memset(cmd, 0, sizeof(cmd)); /* paranoia */

    /* setup stdarg */
    va_start(ap, f);
    vsnprintf(cmd, MU_BUF, f, ap);
    va_end(ap);

    while (*s) {
	sendcnow(*s++);
    }
}

/*
 * sendcnow: send a character to the Rogue process. This routine also does
 * the logging of characters in echo mode.
 */

static void
sendcnow(char c)
{
    if (replaying) {
	return;
    }

    /*
     * slow down the display by waiting usleep_usec microseconds
     *
     * By default usleep_usec is USLEEP.  The -U usec command line option
     * may change this value.
     *
     * If usleep_usec <= 0, then no sleeping is performed.
     */

    if ((usleep_usec > 0) && (!noterm)) {
	usleep(usleep_usec);
    }

    rogue_log_write_command(c);

    fprintf(trogue, "%c", c);
}

/*
 * send: add a string to the queue of commands to be sent to Rogue. The
 * commands are sent one at a time by the resend routine.
 */

#define bump(p, sizeq) (p) = ((p) + 1) % sizeq

/* VARARGS1 */
void
rogo_send(char *f, ...)
{
    char cmd[MU_BUF + 1]; /* command string, +1 for paranoia */
    char *s = cmd;
    va_list ap;

    /* zeroize arrays */
    memset(cmd, 0, sizeof(cmd)); /* paranoia */

    va_start(ap, f);
    vsnprintf(s, MU_BUF, f, ap);
    va_end(ap);

    for (; *s; bump(tail, SENDQ)) {
	queue[tail] = *(s++);
    }

    /* Appends NUL, so resend will treat as a unit */
    queue[tail] = '\0';
    bump(tail, SENDQ);
}

/*
 * resend: Send next block of characters from the queue
 */

int
resend(void)
{
    char *l = lastcmd; /* Ptr into last command */

    morecount = 0; /* Clear message count */

    if (head == tail) {
	return (0); /* Fail if no commands */
    }

    /* Send all queued characters until the next queued NULL */
    while (queue[head]) {
	sendcnow(*l++ = queue[head]);
	bump(head, SENDQ);
    }

    bump(head, SENDQ);
    *l = '\0';

    return (1); /* Return success */
}

/*
 * pending: Return true if there is a command in the queue to be sent to
 * Rogue.
 */

static int
pending(void)
{
    return (head != tail);
}

/*
 * at: move the cursor. Now just a call to move();
 */

void
at(int r, int c)
{
    if (!valrc(r, c)) {
	return;
    }

    move(r, c);
}

/*
 * deadrogue: Called when we have been killed, it reads the tombstone
 * to see how much we had when we died and who killed us. It then
 * calls quitrogue to handle the termination handshaking and log the
 * game.
 */

#define GOLDROW 15
#define KILLROW 17
#define TOMBCOL 19

static void
deadrogue(void)
{
    int mh;
    char *killer, *killend;

    printw("\n\nOh dear, %s died while inside the dungeon!", (playername[0] == '\0') ? "((rogo-rogue))" : playername);
    if (!quiet) {
	refresh();
    }

    sscanf(&screen[GOLDROW][TOMBCOL], "%18d", &Gold);

    killer = &screen[KILLROW][TOMBCOL];
    killend = killer + 17;

    while (*killer == ' ') {
	++killer;
    }

    while (*killend == ' ') {
	*(killend--) = '\0';
    }

    /* Record the death blow if killed by a monster */
    if ((mh = findmonster(killer)) != NONE) {
	addprob(&monhist[mh].theyhit, SUCCESS);
	addstat(&monhist[mh].damage, Hp);
    }

    quitrogue(killer, Gold, DIED);
}

/*
 * quitrogue: we are going to quit. Log the game and send a \n to
 * the Rogue process, then wait for it to die before returning.
 */

/* reason - A reason string for the summary line */
/* gid - What is the final score */
/* terminationtype - SAVED, FINSISHED, or DIED */
void
quitrogue(char *reason, int gld, int terminationtype)
{
    struct tm *ts;
    long clock;
    char *k, *r;
    int stat_loc = -1;	 /* waitpid() information on rogpid */
    int options;	 /* waitpid() options */
    int quarter_seconds; /* 1/4 seconds spent waiting */
    int ret;		 /* waitpid() return */

    /* Save the killer and score */
    for (k = ourkiller, r = reason; *r && *r != ' '; ++k, ++r) {
	*k = *r;
    }

    *k = '\0';
    ourscore = gld;

    /* Don't need to make up any more commands */
    if (!replaying || !logdigested) {
	playing = false;
    }

    /* Now get the current time, so we can date the score */
    clock = time(&clock);
    ts = localtime(&clock);

    /* Build a summary line */
    memset(sumline, 0, sizeof(sumline)); /* paranoia */
#if defined(NOTE_CREATIVE_MODE)
    snprintf(sumline, SM_BUF, "%4d %3s %02d %02d:%02d:%02d %-.32s %7d%s%-17.17s %3d %3d ", 1900 + ts->tm_year, month[ts->tm_mon],
	     ts->tm_mday, ts->tm_hour, ts->tm_min, ts->tm_sec, getname(), gld, creative ? "*" : " ", reason, MaxLevel, Hpmax);
#else
    snprintf(sumline, SM_BUF, "%4d %3s %02d %02d:%02d:%02d %-.32s %7d%s%-17.17s %3d %3d ", 1900 + ts->tm_year, month[ts->tm_mon],
	     ts->tm_mday, ts->tm_hour, ts->tm_min, ts->tm_sec, getname(), gld, " ", reason, MaxLevel, Hpmax);
#endif

    memset(sumline2, 0, sizeof(sumline2)); /* paranoia */
    if (Str % 100) {
	snprintf(sumline2, BIGBUF, "%.*s%2d.%2d", SM_BUF, sumline, Str / 100, Str % 100);
    } else {
	snprintf(sumline2, BIGBUF, "%.*s  %2d ", SM_BUF, sumline, Str / 100);
    }

    memset(sumline, 0, sizeof(sumline)); /* paranoia */
    snprintf(sumline, BIGBUF, "%.*s %2d %2d/%-6d %6d %-10u", SM_BUF, sumline2, Ac, Explev, Exp, ltm.gamecnt, dnum);

    /* Now write the summary line to the log file */
    at(R - 1, 0);
    clrtoeol();
    if (!quiet) {
	refresh();
    }

    /* R-2 is index of score in sumline */
    if (!replaying) {
	add_score(sumline, versionstr, (terse || emacs || noterm));
    }

    /* Set the termination message based on the termination method */
    if (stlmatch(reason, "total winner")) {
	termination = "victorius";
    } else if (stlmatch(reason, "user typing quit")) {
	termination = "abortivus";
    } else if (stlmatch(reason, "gave up")) {
	termination = "inops consilii";
    } else if (stlmatch(reason, "quit (scoreboard)")) {
	termination = "callidus";
    } else if (stlmatch(reason, "saved")) {
	termination = "suspendus";
    }

    /*
     * record the final state to the end of the level log
     */
    levellog_append(reason);

    /* Send the requisite handshaking to Rogue */
    critical(); /* avoid SIGPIPE if rogue process as exited */
    if (terminationtype == DIED) {
	if (version >= RV54A) {
	    sendnow("\n\n");
	} else {
	    sendnow("\n");
	}
    } else if (terminationtype == FINISHED) {
	sendnow("Qy\n");
    } else {
	sendnow("Syy"); /* Must send two yesses,  R5.2 MLM */
    }
    uncritical(); /* restore interrupts */

    /*
     * look for a rogue process, either running, or stopped, or a killed zombie process
     */
    if (rogpid < 0) {
	quit(1, "ERROR: %s: file: %s line: %d dungeon: %u no rogue pid to wait for: %d\n", __func__, __FILE__, __LINE__, dnum,
	     rogpid);
	not_reached();
    }
    options = (WNOHANG | WUNTRACED);
    quarter_seconds = 0;
    usleep(250000); /* sleep 0.25 seconds to allow rogue(6) to exit before our 1st waitpid() call */
    do {

	/* look for a rogue process status */
	++quarter_seconds;
	errno = 0;
	ret = waitpid(rogpid, &stat_loc, options);

	/* if there is not yet rogue status, wait for a second */
	if (ret == 0) {
	    if (quarter_seconds > 4) {
		fprintf(stderr, "still waiting after %.2f seconds for rogue pid %d to exit\n", (double)quarter_seconds / 4.0,
			rogpid);
	    }
	    if (quarter_seconds * 4 > ROGUE_SECONDS) {
		break;
	    }
	    usleep(250000); /* sleep 0.25 seconds */
	}
    } while ((ret == 0 && quarter_seconds * 4 <= ROGUE_SECONDS) || (ret < 0 && errno == EINTR));
    if (ret < 0) {
	switch (errno) {
	case EINVAL:
	    quit(1, "ERROR: %s: file: %s line: %d dungeon: %u waitpid (%d, &stat_loc, 0x%x) invalid options: %s\n", __func__,
		 __FILE__, __LINE__, dnum, rogpid, options, strerror(errno));
	    not_reached();
	    break;

	case ECHILD:
	    quit(1, "ERROR: %s: file: %s line: %d dungeon: %u waitpid (%d, &stat_loc, 0x%x) cannot obtain process status: %s\n",
		 __func__, __FILE__, __LINE__, dnum, rogpid, options, strerror(errno));
	    not_reached();
	    break;

	default:
	    quit(1, "ERROR: %s: file: %s line: %d dungeon: %u waitpid (%d, &stat_loc, 0x%x) returned: %d: %s\n", __func__,
		 __FILE__, __LINE__, dnum, rogpid, options, ret, strerror(errno));
	    not_reached();
	    break;
	}
    }

    /*
     * analyze the status of the rogue process as returned by waitpid()
     *
     * We need to be sure that the rogue process quit.  If the rogue process is still running,
     * try to kill it nicely (with a SIGHUP) before terminating it.
     */
    if (stat_loc == -1) {
	fprintf(stderr, "\nrogue pid %d appears to have previously exited\n", rogpid);
	return;
    }
    if (ret == 0 || WIFSTOPPED(stat_loc) || WIFCONTINUED(stat_loc)) {

	/* we waited ROGUE_SECONDS seconds for rogue status to become available, assume rogue is stuck and SIGHUP it */
	fprintf(stderr, "\nattempting to kill rogue pid %d with SIGHUP...\n", rogpid);
	errno = 0;
	ret = kill(rogpid, SIGHUP);
	if (ret < 0 && errno == ESRCH) {
	    fprintf(stderr, "\nrogue pid %d exited before the SIGHUP attempt\n", rogpid);
	    return;
	}

	/* look for a rogue process status */
	errno = 0;
	ret = waitpid(rogpid, &stat_loc, options);

	/* if there is not yet rogue status, kill SIGTERM it */
	if (ret == 0) {

	    fprintf(stderr, "\nattempting to kill rogue pid %d with SIGTERM...\n", rogpid);
	    errno = 0;
	    ret = kill(rogpid, SIGTERM);
	    if (ret < 0 && errno == ESRCH) {
		fprintf(stderr, "\nrogue pid %d exited after the SIGHUP kill attempt\n", rogpid);
		return;
	    }
	}
    }
    return;
}

/*
 * waitfor: snarf characters from Rogue until a string is found.
 *          The characters are echoed to the users screen.
 *
 *          The string must not contain a valid prefix of itself
 *          internally.
 *
 * MLM 8/27/82
 */

void
waitfor(char *mess)
{
    char *m = mess;

    set_alarm(); /* in case we hang reading from rogue, set a timeout timer */
    while (*m) {
	if (getroguetoken() == *m) {
	    m++;
	} else {
	    m = mess;
	}
    }
    clear_alarm(); /* we did not hang, cancel the timeout timer */
}

/*
 * say: Display a message on the top line. Restore cursor to Rogue.
 */

void
say(char *f, ...)
{
    char buf[BUFSIZ + 1]; /* message buffer, +1 for paranoia */
    char *b;
    va_list ap;

    if (!emacs && !terse && !quiet) {
	memset(buf, 0, sizeof(buf)); /* paranoia */
	va_start(ap, f);
	vsnprintf(buf, BUFSIZ, f, ap);
	va_end(ap);

	at(0, 0);

	for (b = buf; *b; b++) {
	    printw("%s", unctrl(*b));
	}

	clrtoeol();
	at(row, col);
    }
}

/*
 * saynow: Display a message on the top line. Restore cursor to Rogue,
 *         and refresh the screen.
 *
 * NOTE: Special case: f == NULL ==> do not format / "say" anything, just refresh the screen.
 */

void
saynow(char *f, ...)
{
    char buf[BUFSIZ + 1]; /* message buffer, +1 for paranoia */
    char *b;
    va_list ap;

    if (!emacs && !terse && !quiet) {
	memset(buf, 0, sizeof(buf)); /* paranoia */
	if (f != NULL) {
	    va_start(ap, f);
	    vsnprintf(buf, BUFSIZ, f, ap);
	    va_end(ap);
	}

	at(0, 0);

	for (b = buf; *b; b++) {
	    printw("%s", unctrl(*b));
	}

	clrtoeol();
	at(row, col);
    }
    if (!quiet) {
	refresh();
    }
}

/*
 * waitforspace: Wait for the user to type a space.
 * Be sure to interpret a snapshot command, if given.
 */

static void
waitforspace(void)
{
    char ch;

    if (!quiet) {
	refresh();
    }

    if (!noterm) {
	set_alarm(); /* in case we hang reading from rogue, set a timeout timer */
	while ((ch = fgetc(stdin)) != ' ') {
	    if (ch == '/') {
		dosnapshot();
	    }
	}
	clear_alarm(); /* we did not hang, cancel the timeout timer */
    }

    at(row, col);
}

/*
 * givehelp: Each time a ? is pressed, this routine prints the next
 * help message in a sequence of help messages. Nexthelp is an
 */

static char *nexthelp[] = {"Rgm commands: t=toggle run mode, e=logging, i=inventory, -=status    [?]",
			   "Rgm commands: <ret>=singlestep, `=summary, /=snapshot, R=replay      [?]",
			   "Rgm commands: m=long term memory display, G=display gene settings    [?]",
			   "Rogue cmds: S=Save, Q=Quit, h j k l H J K L b n u y N B U Y f s < >  [?]",
			   "Wizard: d=debug, !=show items, @=show monsters, #=show level flags   [?]",
			   "Wizard: ~=version, ^=bowrank, %%=armorrank, $=weaponrank, ==ringrank  [?]",
			   "Wizard: (=database, )=cycles, +=possible secret doors, :=chicken     [?]",
			   "Wizard: [=weapstat, ]=rustproof armor, r=resetinv, &=object count    [?]",
			   "Wizard: *=toggle blind, C=toggle cosmic, M=mazedoor, A=attempt, {=flags",
			   NULL};

static char **helpline = nexthelp;

void
givehelp(void)
{
    if (*helpline == NULL) {
	helpline = nexthelp;
    }

    saynow("%s", *helpline++);
}

/*
 * pauserogue: Wait for the user to type a space and then redraw the
 *             screen. Now uses the stored image and passes it to
 *             curses rather than sending a form feed to Rogue. MLM
 */

void
pauserogue(void)
{
    at(R - 1, 0);
    addstr("--More--");
    clrtoeol();
    if (!quiet) {
	refresh();
    }

    waitforspace();

    redrawscreen();
}

/*
 * getrogver: Read the output of the Rogue version command
 *            and set version. RV36B = 362 (3.6 with wands)
 *            and RV52A = 521 (5.2). Note that RV36A is
 *            infered when we send a "//" command to identify
 *            wands.
 *
 * Get version from first 2000 chars of a log file	Feb 9, 1985 - mlm
 */

#define VERMSG "ersion "

void
getrogver(void)
{
    char *vstr = versionstr, *m = VERMSG;
    int cnt = 2000, ch;

    if (replaying) { /* Look for version string in log */
	while (cnt-- > 0 && *m) {
	    if (fgetc(logfile) == *m) {
		m++;
	    } else {
		m = VERMSG;
	    }
	}

	if (*m == '\0') { /* Found VERMSG, get version string */
	    while ((ch = fgetc(logfile)) != ' ') {
		*(vstr++) = ch;
	    }

	    *--vstr = '\0';
	} else {				       /* Use default version */
	    memset(versionstr, 0, sizeof(versionstr)); /* paranoia */
	    snprintf(versionstr, MU_BUF, DEFVER);
	}

	rewind(logfile); /* Put log file back to start */

    } else { /* Execute the version command */
	sendnow("v");
	waitfor("ersion ");

	set_alarm(); /* in case we hang reading from rogue, set a timeout timer */
	while ((ch = getroguetoken()) != ' ') {
	    *vstr = ch;
	    vstr++;
	}
	clear_alarm(); /* we did not hang, cancel the timeout timer */
    }

    if (stlmatch(versionstr, "3.6")) {
	version = RV36B;
    } else if (stlmatch(versionstr, "5.2")) {
	version = RV52A;
    } else if (stlmatch(versionstr, "5.3")) {
	version = RV53A;
    } else if (stlmatch(versionstr, "5.4.4")) {
	version = RV54A;
    } else if (stlmatch(versionstr, "5.4.5")) {
	version = RV54B;
	creative = true; /* rogue 5.4.5 or later enables creative mode by default */
    } else {

	/*
	 * unable too parse the rogue version
	 */
	saynow("What a strange version of Rogue! ");

	/* use the default rogue version number */
	version = DEFRV;

	/* use the default rogue version string */
	memset(versionstr, 0, sizeof(versionstr)); /* paranoia */
	snprintf(versionstr, MU_BUF, DEFVER);
    }
}

/*
 * charsavail: How many characters are there at the terminal? If any
 * characters are found, 'noterm' is reset, since there is obviously
 * a terminal around if the user is typing at us.
 */

int
charsavail(void)
{
    long n;
    int retc;

    retc = ioctl(READ, FIONREAD, &n);
    if (retc) {
	saynow("Ioctl returns %d, n=%ld.\n", retc, n);
	n = 0;
    }

    if (n > 0) {
	noterm = false;
    }

    return ((int)n);
}

/*
 * redrawscreen: Make the users screen look like the Rogue screen (screen).
 */

void
redrawscreen(void)
{
    int i, j;
    char ch;

    clear();

    for (i = 1; i < R; i++) {
	for (j = 0; j < C; j++) {
	    if ((ch = screen[i][j]) > ' ') {
		mvaddch(i, j, ch);
	    }
	}
    }

    at(row, col);

    if (!quiet) {
	refresh();
    }
}

/*
 * toggleecho: toggle the I/O echo feature. If first time, open the
 * roguelog file.
 */

void
toggleecho(void)
{
    if (replaying) {
	return;
    }

    logging = !logging;

    if (logging) {
	if (!rogue_log_open(gamelog_path)) {
	    logging = false;
	    saynow("can't open %s", gamelog_path);
	} else {
	    saynow("Logging to file %s", gamelog_path);

	    if (*versionstr) {
		command(T_OTHER, "v");
	    }
	}
    } else {
	rogue_log_close();

	if (playing) {
	    saynow("File %s closed", gamelog_path);
	}
    }

    if (playing) {
	at(row, col);
	if (!quiet) {
	    refresh();
	}
    }
}

/*
 * clearsendqueue: Throw away queued Rogue commands.
 */

void
clearsendqueue(void)
{
    head = tail;
}

/*
 * startreplay: Open the log file to replay.
 */

void
startreplay(FILE **logf, char *logfname)
{
    if ((*logf = fopen(logfname, "r")) == NULL) {
	fprintf(stderr, "Can't open '%s'.\n", logfname);
	exit(1);
    }
}

/*
 * putn: Put 'n' copies of character 'c' on file 'f'.
 */

static void
putn(char c, FILE *f, int n)
{
    while (n--) {
	putc(c, f);
    }
}

/*
 * printsnap: print a snapshot to file f.
 */

void
printsnap(FILE *f)
{
    int i, j, length;
    struct tm *ts;
    long clock;

    /* Now get the current time, so we can date the snapshot */
    clock = time(&clock);
    ts = localtime(&clock);

    /* Print snapshot timestamp */
    fprintf(f, "\nSnapshot taken on %s %d, %d at %02d:%02d:%02d:\n\n", month[ts->tm_mon], ts->tm_mday, 1900 + ts->tm_year,
	    ts->tm_hour, ts->tm_min, ts->tm_sec);

    /* Print the current map */
    putn('-', f, C - 1);
    fprintf(f, "\n");

    for (i = 0; i < R; i++) {
	for (length = C - 1; length >= 0 && charonscreen(i, length) == ' '; length--)
	    ;

	for (j = 0; j <= length; j++) {
	    fprintf(f, "%c", charonscreen(i, j));
	}

	fprintf(f, "\n");
    }

    putn('-', f, C - 1);

    /* Print status variables */
    fprintf(f, "\n\n%s\n\n", statusline());

    /* Print the inventory */

    dumpinv(f);
    fprintf(f, "\n");
    putn('-', f, C - 1);
    fprintf(f, "\n");
}

/*
 * dosnapshot: add a snapshot to the SHAPSHOT file.
 */

void
dosnapshot(void)
{
    if ((snapshot = wopen(SNAPSHOT, "a")) == NULL) {
	saynow("Cannot write file %s.", SNAPSHOT);
    } else {
	printsnap(snapshot);
	fclose(snapshot);
	saynow("Snapshot added to %s.", SNAPSHOT);
    }
}

/*
 * clearscreen: Done whenever a {ff} is sent by Rogue.  This code is
 * separate so it can be called from replay(), since there is an implicit
 * formfeed not recorded in the log file.   MLM
 */

void
clearscreen(void)
{
    int i, j;

    row = col = 0;
    clear();
    screen00 = ' ';

    for (i = 0; i < R; i++) {
	for (j = 0; j < C; j++) {
	    screen[i][j] = ' ';
	    scrmap[i][j] = SCRMINIT;
	}
    }

    initstufflist();
    mlistlen = 0; /* initmonsterlist (); temp hack MLM */
}

/*
 * statusline: Write all about our current status into a string.
 * Returns a pointer to a static area.			MLM
 */

char *
statusline(void)
{
    static char staticarea[BIGBUF + 1];	 /* +1 for paranoia */
    static char staticarea2[BIGBUF + 1]; /* +1 for paranoia */
    char *ret;				 /* static buffer to return as a NUL terminated string */

    memset(staticarea, 0, sizeof(staticarea)); /* paranoia */
    strlcpy(staticarea, "Status: ", sizeof(staticarea));

    if (aggravated) {
	strlcat(staticarea, "aggravated, ", sizeof(staticarea));
    }

    if (beingheld) {
	strlcat(staticarea, "being held, ", sizeof(staticarea));
    }

    if (blinded) {
	strlcat(staticarea, "blind, ", sizeof(staticarea));
    }

    if (confused) {
	strlcat(staticarea, "confused, ", sizeof(staticarea));
    }

    if (cosmic) {
	strlcat(staticarea, "cosmic, ", sizeof(staticarea));
    }

    if (cursedarmor) {
	strlcat(staticarea, "cursed armor, ", sizeof(staticarea));
    }

    if (cursedweapon) {
	strlcat(staticarea, "cursed weapon, ", sizeof(staticarea));
    }

    if (doublehasted) {
	strlcat(staticarea, "perm hasted, ", sizeof(staticarea));
    }

    if (droppedscare) {
	strlcat(staticarea, "dropped scare, ", sizeof(staticarea));
    }

    if (diddrop) {
	strlcat(staticarea, "dropped something, ", sizeof(staticarea));
    }

    if (floating) {
	strlcat(staticarea, "floating, ", sizeof(staticarea));
    }

    if (hasted) {
	strlcat(staticarea, "hasted, ", sizeof(staticarea));
    }

    if (protected) {
	strlcat(staticarea, "protected, ", sizeof(staticarea));
    }

    if (redhands) {
	strlcat(staticarea, "red hands, ", sizeof(staticarea));
    }

    if (Level == didreadmap) {
	strlcat(staticarea, "mapped, ", sizeof(staticarea));
    }

    memset(staticarea2, 0, sizeof(staticarea2)); /* paranoia */
    if (*genocided) {
	snprintf(staticarea2, SM_BUF, "%.*sgenocided '%.*s', ", MU_BUF, staticarea, MU_BUF, genocided);
	snprintf(staticarea, BIGBUF, "%.*s%d food%s, %d missile%s, %d turn%s, (%d,%d %d,%d) bonus", SM_BUF, staticarea2, larder,
		 plural(larder), ammo, plural(ammo), turns, plural(turns), gplushit, gplusdam, wplushit, wplusdam);
	ret = staticarea;
    } else {
	snprintf(staticarea2, BIGBUF, "%.*s%d food%.*s, %d missile%.*s, %d turn%.*s, (%d,%d %d,%d) bonus", SM_BUF, staticarea,
		 larder, MU_BUF, plural(larder), ammo, MU_BUF, plural(ammo), turns, MU_BUF, plural(turns), gplushit, gplusdam,
		 wplushit, wplusdam);
	ret = staticarea2;
    }

    return (ret);
}