[unix-history] / usr / src / games / rogue / room.c

/*
 * room.c
 *
 * This source herein may be modified and/or distributed by anybody who
 * so desires, with the following restrictions:
 *    1.)  No portion of this notice shall be removed.
 *    2.)  Credit shall not be taken for the creation of this source.
 *    3.)  This code is not to be traded, sold, or used for personal
 *         gain or profit.
 *
 */

#ifndef lint
static char sccsid[] = "@(#)room.c	5.1 (Berkeley) %G%";
#endif /* not lint */

#include "rogue.h"

room rooms[MAXROOMS];
boolean rooms_visited[MAXROOMS];

extern short blind;
extern boolean detect_monster, jump, passgo, no_skull, ask_quit;
extern char *nick_name, *fruit, *save_file, *press_space;

#define NOPTS 7

struct option {
	char *prompt;
	boolean is_bool;
	char **strval;
	boolean *bval;
} options[NOPTS] = {
	{
		"Show position only at end of run (\"jump\"): ",
		1, (char **) 0, &jump
	},
	{
		"Follow turnings in passageways (\"passgo\"): ",
		1, (char **) 0, &passgo
	},
	{
		"Don't print skull when killed (\"noskull\" or \"notombstone\"): ",
		1, (char **) 0, &no_skull
	},
	{
		"Ask player before saying 'Okay, bye-bye!' (\"askquit\"): ",
		1, (char **) 0, &ask_quit
	},
	{
		"Name (\"name\"): ",
		0, &nick_name
	},
	{
		"Fruit (\"fruit\"): ",
		0, &fruit
	},
	{
		"Save file (\"file\"): ",
		0, &save_file
	}
};

light_up_room(rn)
int rn;
{
	short i, j;

	if (!blind) {
		for (i = rooms[rn].top_row;
			i <= rooms[rn].bottom_row; i++) {
			for (j = rooms[rn].left_col;
				j <= rooms[rn].right_col; j++) {
				if (dungeon[i][j] & MONSTER) {
					object *monster;

					if (monster = object_at(&level_monsters, i, j)) {
						dungeon[monster->row][monster->col] &= (~MONSTER);
						monster->trail_char =
							get_dungeon_char(monster->row, monster->col);
						dungeon[monster->row][monster->col] |= MONSTER;
					}
				}
				mvaddch(i, j, get_dungeon_char(i, j));
			}
		}
		mvaddch(rogue.row, rogue.col, rogue.fchar);
	}
}

light_passage(row, col)
{
	short i, j, i_end, j_end;

	if (blind) {
		return;
	}
	i_end = (row < (DROWS-2)) ? 1 : 0;
	j_end = (col < (DCOLS-1)) ? 1 : 0;

	for (i = ((row > MIN_ROW) ? -1 : 0); i <= i_end; i++) {
		for (j = ((col > 0) ? -1 : 0); j <= j_end; j++) {
			if (can_move(row, col, row+i, col+j)) {
				mvaddch(row+i, col+j, get_dungeon_char(row+i, col+j));
			}
		}
	}
}

darken_room(rn)
short rn;
{
	short i, j;

	for (i = rooms[rn].top_row + 1; i < rooms[rn].bottom_row; i++) {
		for (j = rooms[rn].left_col + 1; j < rooms[rn].right_col; j++) {
			if (blind) {
				mvaddch(i, j, ' ');
			} else {
				if (!(dungeon[i][j] & (OBJECT | STAIRS)) &&
					!(detect_monster && (dungeon[i][j] & MONSTER))) {
					if (!imitating(i, j)) {
						mvaddch(i, j, ' ');
					}
					if ((dungeon[i][j] & TRAP) && (!(dungeon[i][j] & HIDDEN))) {
						mvaddch(i, j, '^');
					}
				}
			}
		}
	}
}

get_dungeon_char(row, col)
register row, col;
{
	register unsigned short mask = dungeon[row][col];

	if (mask & MONSTER) {
		return(gmc_row_col(row, col));
	}
	if (mask & OBJECT) {
		object *obj;

		obj = object_at(&level_objects, row, col);
		return(get_mask_char(obj->what_is));
	}
	if (mask & (TUNNEL | STAIRS | HORWALL | VERTWALL | FLOOR | DOOR)) {
		if ((mask & (TUNNEL| STAIRS)) && (!(mask & HIDDEN))) {
			return(((mask & STAIRS) ? '%' : '#'));
		}
		if (mask & HORWALL) {
			return('-');
		}
		if (mask & VERTWALL) {
			return('|');
		}
		if (mask & FLOOR) {
			if (mask & TRAP) {
				if (!(dungeon[row][col] & HIDDEN)) {
					return('^');
				}
			}
			return('.');
		}
		if (mask & DOOR) {
			if (mask & HIDDEN) {
				if (((col > 0) && (dungeon[row][col-1] & HORWALL)) ||
					((col < (DCOLS-1)) && (dungeon[row][col+1] & HORWALL))) {
					return('-');
				} else {
					return('|');
				}
			} else {
				return('+');
			}
		}
	}
	return(' ');
}

get_mask_char(mask)
register unsigned short mask;
{
		switch(mask) {
		case SCROL:
			return('?');
		case POTION:
			return('!');
		case GOLD:
			return('*');
		case FOOD:
			return(':');
		case WAND:
			return('/');
		case ARMOR:
			return(']');
		case WEAPON:
			return(')');
		case RING:
			return('=');
		case AMULET:
			return(',');
		default:
			return('~');	/* unknown, something is wrong */
		}
}

gr_row_col(row, col, mask)
short *row, *col;
unsigned short mask;
{
	short rn;
	short r, c;

	do {
		r = get_rand(MIN_ROW, DROWS-2);
		c = get_rand(0, DCOLS-1);
		rn = get_room_number(r, c);
	} while ((rn == NO_ROOM) ||
		(!(dungeon[r][c] & mask)) ||
		(dungeon[r][c] & (~mask)) ||
		(!(rooms[rn].is_room & (R_ROOM | R_MAZE))) ||
		((r == rogue.row) && (c == rogue.col)));

	*row = r;
	*col = c;
}

gr_room()
{
	short i;

	do {
		i = get_rand(0, MAXROOMS-1);
	} while (!(rooms[i].is_room & (R_ROOM | R_MAZE)));

	return(i);
}

party_objects(rn)
{
	short i, j, nf = 0;
	object *obj;
	short n, N, row, col;
	boolean found;

	N = ((rooms[rn].bottom_row - rooms[rn].top_row) - 1) *
		((rooms[rn].right_col - rooms[rn].left_col) - 1);
	n =  get_rand(5, 10);
	if (n > N) {
		n = N - 2;
	}
	for (i = 0; i < n; i++) {
		for (j = found = 0; ((!found) && (j < 250)); j++) {
			row = get_rand(rooms[rn].top_row+1,
					   rooms[rn].bottom_row-1);
			col = get_rand(rooms[rn].left_col+1,
					   rooms[rn].right_col-1);
			if ((dungeon[row][col] == FLOOR) || (dungeon[row][col] == TUNNEL)) {
				found = 1;
			}
		}
		if (found) {
			obj = gr_object();
			place_at(obj, row, col);
			nf++;
		}
	}
	return(nf);
}

get_room_number(row, col)
register row, col;
{
	short i;

	for (i = 0; i < MAXROOMS; i++) {
		if ((row >= rooms[i].top_row) && (row <= rooms[i].bottom_row) &&
			(col >= rooms[i].left_col) && (col <= rooms[i].right_col)) {
			return(i);
		}
	}
	return(NO_ROOM);
}

is_all_connected()
{
	short i, starting_room;

	for (i = 0; i < MAXROOMS; i++) {
		rooms_visited[i] = 0;
		if (rooms[i].is_room & (R_ROOM | R_MAZE)) {
			starting_room = i;
		}
	}

	visit_rooms(starting_room);

	for (i = 0; i < MAXROOMS; i++) {
		if ((rooms[i].is_room & (R_ROOM | R_MAZE)) && (!rooms_visited[i])) {
			return(0);
		}
	}
	return(1);
}

visit_rooms(rn)
int rn;
{
	short i;
	short oth_rn;

	rooms_visited[rn] = 1;

	for (i = 0; i < 4; i++) {
		oth_rn = rooms[rn].doors[i].oth_room;
		if ((oth_rn >= 0) && (!rooms_visited[oth_rn])) {
			visit_rooms(oth_rn);
		}
	}
}

draw_magic_map()
{
	short i, j, ch, och;
	unsigned short mask = (HORWALL | VERTWALL | DOOR | TUNNEL | TRAP | STAIRS |
			MONSTER);
	unsigned short s;

	for (i = 0; i < DROWS; i++) {
		for (j = 0; j < DCOLS; j++) {
			s = dungeon[i][j];
			if (s & mask) {
				if (((ch = mvinch(i, j)) == ' ') ||
					((ch >= 'A') && (ch <= 'Z')) || (s & (TRAP | HIDDEN))) {
					och = ch;
					dungeon[i][j] &= (~HIDDEN);
					if (s & HORWALL) {
						ch = '-';
					} else if (s & VERTWALL) {
						ch = '|';
					} else if (s & DOOR) {
						ch = '+';
					} else if (s & TRAP) {
						ch = '^';
					} else if (s & STAIRS) {
						ch = '%';
					} else if (s & TUNNEL) {
						ch = '#';
					} else {
						continue;
					}
					if ((!(s & MONSTER)) || (och == ' ')) {
						addch(ch);
					}
					if (s & MONSTER) {
						object *monster;

						if (monster = object_at(&level_monsters, i, j)) {
							monster->trail_char = ch;
						}
					}
				}
			}
		}
	}
}

dr_course(monster, entering, row, col)
object *monster;
boolean entering;
short row, col;
{
	short i, j, k, rn;
	short r, rr;

	monster->row = row;
	monster->col = col;

	if (mon_sees(monster, rogue.row, rogue.col)) {
		monster->trow = NO_ROOM;
		return;
	}
	rn = get_room_number(row, col);

	if (entering) {		/* entering room */
		/* look for door to some other room */
		r = get_rand(0, MAXROOMS-1);
		for (i = 0; i < MAXROOMS; i++) {
			rr = (r + i) % MAXROOMS;
			if ((!(rooms[rr].is_room & (R_ROOM | R_MAZE))) || (rr == rn)) {
				continue;
			}
			for (k = 0; k < 4; k++) {
				if (rooms[rr].doors[k].oth_room == rn) {
					monster->trow = rooms[rr].doors[k].oth_row;
					monster->tcol = rooms[rr].doors[k].oth_col;
					if ((monster->trow == row) &&
						(monster->tcol == col)) {
						continue;
					}
					return;
				}
			}
		}
		/* look for door to dead end */
		for (i = rooms[rn].top_row; i <= rooms[rn].bottom_row; i++) {
			for (j = rooms[rn].left_col; j <= rooms[rn].right_col; j++) {
				if ((i != monster->row) && (j != monster->col) &&
					(dungeon[i][j] & DOOR)) {
					monster->trow = i;
					monster->tcol = j;
					return;
				}
			}
		}
		/* return monster to room that he came from */
		for (i = 0; i < MAXROOMS; i++) {
			for (j = 0; j < 4; j++) {
				if (rooms[i].doors[j].oth_room == rn) {
					for (k = 0; k < 4; k++) {
						if (rooms[rn].doors[k].oth_room == i) {
							monster->trow = rooms[rn].doors[k].oth_row;
							monster->tcol = rooms[rn].doors[k].oth_col;
							return;
						}
					}
				}
			}
		}
		/* no place to send monster */
		monster->trow = NO_ROOM;
	} else {		/* exiting room */
		if (!get_oth_room(rn, &row, &col)) {
			monster->trow = NO_ROOM;
		} else {
			monster->trow = row;
			monster->tcol = col;
		}
	}
}

get_oth_room(rn, row, col)
short rn, *row, *col;
{
	short d = -1;

	if (*row == rooms[rn].top_row) {
		d = UPWARD/2;
	} else if (*row == rooms[rn].bottom_row) {
		d = DOWN/2;
	} else if (*col == rooms[rn].left_col) {
		d = LEFT/2;
	} else if (*col == rooms[rn].right_col) {
		d = RIGHT/2;
	}
	if ((d != -1) && (rooms[rn].doors[d].oth_room >= 0)) {
		*row = rooms[rn].doors[d].oth_row;
		*col = rooms[rn].doors[d].oth_col;
		return(1);
	}
	return(0);
}

edit_opts()
{
	char save[NOPTS+1][DCOLS];
	short i, j;
	short ch;
	boolean done = 0;
	char buf[MAX_OPT_LEN + 2];

	for (i = 0; i < NOPTS+1; i++) {
		for (j = 0; j < DCOLS; j++) {
			save[i][j] = mvinch(i, j);
		}
		if (i < NOPTS) {
			opt_show(i);
		}
	}
	opt_go(0);
	i = 0;

	while (!done) {
		refresh();
		ch = rgetchar();
CH:
		switch(ch) {
		case '\033':
			done = 1;
			break;
		case '\012':
		case '\015':
			if (i == (NOPTS - 1)) {
				mvaddstr(NOPTS, 0, press_space);
				refresh();
				wait_for_ack();
				done = 1;
			} else {
				i++;
				opt_go(i);
			}
			break;
		case '-':
			if (i > 0) {
				opt_go(--i);
			} else {
				sound_bell();
			}
			break;
		case 't':
		case 'T':
		case 'f':
		case 'F':
			if (options[i].is_bool) {
				*(options[i].bval) = (((ch == 't') || (ch == 'T')) ? 1 : 0);
				opt_show(i);
				opt_go(++i);
				break;
			}
		default:
			if (options[i].is_bool) {
				sound_bell();
				break;
			}
			j = 0;
			if ((ch == '\010') || ((ch >= ' ') && (ch <= '~'))) {
				opt_erase(i);
				do {
					if ((ch >= ' ') && (ch <= '~') && (j < MAX_OPT_LEN)) {
						buf[j++] = ch;
						buf[j] = '\0';
						addch(ch);
					} else if ((ch == '\010') && (j > 0)) {
						buf[--j] = '\0';
						move(i, j + strlen(options[i].prompt));
						addch(' ');
						move(i, j + strlen(options[i].prompt));
					}
					refresh();
					ch = rgetchar();
				} while ((ch != '\012') && (ch != '\015') && (ch != '\033'));
				if (j != 0) {
					(void) strcpy(*(options[i].strval), buf);
				}
				opt_show(i);
				goto CH;
			} else {
				sound_bell();
			}
			break;
		}
	}

	for (i = 0; i < NOPTS+1; i++) {
		move(i, 0);
		for (j = 0; j < DCOLS; j++) {
			addch(save[i][j]);
		}
	}
}

opt_show(i)
int i;
{
	char *s;
	struct option *opt = &options[i];

	opt_erase(i);

	if (opt->is_bool) {
		s = *(opt->bval) ? "True" : "False";
	} else {
		s = *(opt->strval);
	}
	addstr(s);
}

opt_erase(i)
int i;
{
	struct option *opt = &options[i];

	mvaddstr(i, 0, opt->prompt);
	clrtoeol();
}

opt_go(i)
int i;
{
	move(i, strlen(options[i].prompt));
}

do_shell()
{
#ifdef UNIX
	char *sh;

	md_ignore_signals();
	if (!(sh = md_getenv("SHELL"))) {
		sh = "/bin/sh";
	}
	move(LINES-1, 0);
	refresh();
	stop_window();
	printf("\nCreating new shell...\n");
	md_shell(sh);
	start_window();
	wrefresh(curscr);
	md_heed_signals();
#endif
}
Commit	Line	Data
b3afadef KB	1	/*
	2	* room.c
	3	*
	4	* This source herein may be modified and/or distributed by anybody who
	5	* so desires, with the following restrictions:
	6	* 1.) No portion of this notice shall be removed.
	7	* 2.) Credit shall not be taken for the creation of this source.
	8	* 3.) This code is not to be traded, sold, or used for personal
	9	* gain or profit.
	10	*
	11	*/
	12
	13	#ifndef lint
	14	static char sccsid[] = "@(#)room.c 5.1 (Berkeley) %G%";
	15	#endif /* not lint */
	16
	17	#include "rogue.h"
	18
	19	room rooms[MAXROOMS];
	20	boolean rooms_visited[MAXROOMS];
	21
	22	extern short blind;
	23	extern boolean detect_monster, jump, passgo, no_skull, ask_quit;
	24	extern char nick_name, fruit, save_file, press_space;
	25
	26	#define NOPTS 7
	27
	28	struct option {
	29	char *prompt;
	30	boolean is_bool;
	31	char **strval;
	32	boolean *bval;
	33	} options[NOPTS] = {
	34	{
	35	"Show position only at end of run (\"jump\"): ",
	36	1, (char **) 0, &jump
	37	},
	38	{
	39	"Follow turnings in passageways (\"passgo\"): ",
	40	1, (char **) 0, &passgo
	41	},
	42	{
	43	"Don't print skull when killed (\"noskull\" or \"notombstone\"): ",
	44	1, (char **) 0, &no_skull
	45	},
	46	{
	47	"Ask player before saying 'Okay, bye-bye!' (\"askquit\"): ",
	48	1, (char **) 0, &ask_quit
	49	},
	50	{
	51	"Name (\"name\"): ",
	52	0, &nick_name
	53	},
	54	{
	55	"Fruit (\"fruit\"): ",
	56	0, &fruit
	57	},
	58	{
	59	"Save file (\"file\"): ",
	60	0, &save_file
	61	}
	62	};
	63
	64	light_up_room(rn)
65	int rn;
66	{
67	short i, j;
68
69	if (!blind) {
70	for (i = rooms[rn].top_row;
71	i <= rooms[rn].bottom_row; i++) {
72	for (j = rooms[rn].left_col;
73	j <= rooms[rn].right_col; j++) {
74	if (dungeon[i][j] & MONSTER) {
75	object *monster;
76
77	if (monster = object_at(&level_monsters, i, j)) {
78	dungeon[monster->row][monster->col] &= (~MONSTER);
79	monster->trail_char =
80	get_dungeon_char(monster->row, monster->col);
81	dungeon[monster->row][monster->col] \|= MONSTER;
82	}
83	}
84	mvaddch(i, j, get_dungeon_char(i, j));
85	}
86	}
87	mvaddch(rogue.row, rogue.col, rogue.fchar);
88	}
89	}
90
91	light_passage(row, col)
92	{
93	short i, j, i_end, j_end;
94
95	if (blind) {
96	return;
97	}
98	i_end = (row < (DROWS-2)) ? 1 : 0;
99	j_end = (col < (DCOLS-1)) ? 1 : 0;
100
101	for (i = ((row > MIN_ROW) ? -1 : 0); i <= i_end; i++) {
102	for (j = ((col > 0) ? -1 : 0); j <= j_end; j++) {
103	if (can_move(row, col, row+i, col+j)) {
104	mvaddch(row+i, col+j, get_dungeon_char(row+i, col+j));
105	}
106	}
107	}
108	}
109
110	darken_room(rn)
111	short rn;
112	{
113	short i, j;
114
115	for (i = rooms[rn].top_row + 1; i < rooms[rn].bottom_row; i++) {
116	for (j = rooms[rn].left_col + 1; j < rooms[rn].right_col; j++) {
117	if (blind) {
118	mvaddch(i, j, ' ');
119	} else {
120	if (!(dungeon[i][j] & (OBJECT \| STAIRS)) &&
121	!(detect_monster && (dungeon[i][j] & MONSTER))) {
122	if (!imitating(i, j)) {
123	mvaddch(i, j, ' ');
124	}
125	if ((dungeon[i][j] & TRAP) && (!(dungeon[i][j] & HIDDEN))) {
126	mvaddch(i, j, '^');
127	}
128	}
129	}
130	}
131	}
132	}
133
134	get_dungeon_char(row, col)
135	register row, col;
136	{
137	register unsigned short mask = dungeon[row][col];
138
139	if (mask & MONSTER) {
140	return(gmc_row_col(row, col));
141	}
142	if (mask & OBJECT) {
143	object *obj;
144
145	obj = object_at(&level_objects, row, col);
146	return(get_mask_char(obj->what_is));
147	}
148	if (mask & (TUNNEL \| STAIRS \| HORWALL \| VERTWALL \| FLOOR \| DOOR)) {
149	if ((mask & (TUNNEL\| STAIRS)) && (!(mask & HIDDEN))) {
150	return(((mask & STAIRS) ? '%' : '#'));
151	}
152	if (mask & HORWALL) {
153	return('-');
154	}
155	if (mask & VERTWALL) {
156	return('\|');
157	}
158	if (mask & FLOOR) {
159	if (mask & TRAP) {
160	if (!(dungeon[row][col] & HIDDEN)) {
161	return('^');
162	}
163	}
164	return('.');
165	}
166	if (mask & DOOR) {
167	if (mask & HIDDEN) {
168	if (((col > 0) && (dungeon[row][col-1] & HORWALL)) \|\|
169	((col < (DCOLS-1)) && (dungeon[row][col+1] & HORWALL))) {
170	return('-');
171	} else {
172	return('\|');
173	}
174	} else {
175	return('+');
176	}
177	}
178	}
179	return(' ');
180	}
181
182	get_mask_char(mask)
183	register unsigned short mask;
184	{
185	switch(mask) {
186	case SCROL:
187	return('?');
188	case POTION:
189	return('!');
190	case GOLD:
191	return('*');
192	case FOOD:
193	return(':');
194	case WAND:
195	return('/');
196	case ARMOR:
197	return(']');
198	case WEAPON:
199	return(')');
200	case RING:
201	return('=');
202	case AMULET:
203	return(',');
204	default:
205	return('~'); /* unknown, something is wrong */
206	}
207	}
208
209	gr_row_col(row, col, mask)
210	short row, col;
211	unsigned short mask;
212	{
213	short rn;
214	short r, c;
215
216	do {
217	r = get_rand(MIN_ROW, DROWS-2);
218	c = get_rand(0, DCOLS-1);
219	rn = get_room_number(r, c);
220	} while ((rn == NO_ROOM) \|\|
221	(!(dungeon[r][c] & mask)) \|\|
222	(dungeon[r][c] & (~mask)) \|\|
223	(!(rooms[rn].is_room & (R_ROOM \| R_MAZE))) \|\|
224	((r == rogue.row) && (c == rogue.col)));
225
226	*row = r;
227	*col = c;
228	}
229
230	gr_room()
231	{
232	short i;
233
234	do {
235	i = get_rand(0, MAXROOMS-1);
236	} while (!(rooms[i].is_room & (R_ROOM \| R_MAZE)));
237
238	return(i);
239	}
240
241	party_objects(rn)
242	{
243	short i, j, nf = 0;
244	object *obj;
245	short n, N, row, col;
246	boolean found;
247
248	N = ((rooms[rn].bottom_row - rooms[rn].top_row) - 1) *
249	((rooms[rn].right_col - rooms[rn].left_col) - 1);
250	n = get_rand(5, 10);
251	if (n > N) {
252	n = N - 2;
253	}
254	for (i = 0; i < n; i++) {
255	for (j = found = 0; ((!found) && (j < 250)); j++) {
256	row = get_rand(rooms[rn].top_row+1,
257	rooms[rn].bottom_row-1);
258	col = get_rand(rooms[rn].left_col+1,
259	rooms[rn].right_col-1);
260	if ((dungeon[row][col] == FLOOR) \|\| (dungeon[row][col] == TUNNEL)) {
261	found = 1;
262	}
263	}
264	if (found) {
265	obj = gr_object();
266	place_at(obj, row, col);
267	nf++;
268	}
269	}
270	return(nf);
271	}
272
273	get_room_number(row, col)
274	register row, col;
275	{
276	short i;
277
278	for (i = 0; i < MAXROOMS; i++) {
279	if ((row >= rooms[i].top_row) && (row <= rooms[i].bottom_row) &&
280	(col >= rooms[i].left_col) && (col <= rooms[i].right_col)) {
281	return(i);
282	}
283	}
284	return(NO_ROOM);
285	}
286
287	is_all_connected()
288	{
289	short i, starting_room;
290
291	for (i = 0; i < MAXROOMS; i++) {
292	rooms_visited[i] = 0;
293	if (rooms[i].is_room & (R_ROOM \| R_MAZE)) {
294	starting_room = i;
295	}
296	}
297
298	visit_rooms(starting_room);
299
300	for (i = 0; i < MAXROOMS; i++) {
301	if ((rooms[i].is_room & (R_ROOM \| R_MAZE)) && (!rooms_visited[i])) {
302	return(0);
303	}
304	}
305	return(1);
306	}
307
308	visit_rooms(rn)
309	int rn;
310	{
311	short i;
312	short oth_rn;
313
314	rooms_visited[rn] = 1;
315
316	for (i = 0; i < 4; i++) {
317	oth_rn = rooms[rn].doors[i].oth_room;
318	if ((oth_rn >= 0) && (!rooms_visited[oth_rn])) {
319	visit_rooms(oth_rn);
320	}
321	}
322	}
323
324	draw_magic_map()
325	{
326	short i, j, ch, och;
327	unsigned short mask = (HORWALL \| VERTWALL \| DOOR \| TUNNEL \| TRAP \| STAIRS \|
328	MONSTER);
329	unsigned short s;
330
331	for (i = 0; i < DROWS; i++) {
332	for (j = 0; j < DCOLS; j++) {
333	s = dungeon[i][j];
334	if (s & mask) {
335	if (((ch = mvinch(i, j)) == ' ') \|\|
336	((ch >= 'A') && (ch <= 'Z')) \|\| (s & (TRAP \| HIDDEN))) {
337	och = ch;
338	dungeon[i][j] &= (~HIDDEN);
339	if (s & HORWALL) {
340	ch = '-';
341	} else if (s & VERTWALL) {
342	ch = '\|';
343	} else if (s & DOOR) {
344	ch = '+';
345	} else if (s & TRAP) {
346	ch = '^';
347	} else if (s & STAIRS) {
348	ch = '%';
349	} else if (s & TUNNEL) {
350	ch = '#';
351	} else {
352	continue;
353	}
354	if ((!(s & MONSTER)) \|\| (och == ' ')) {
355	addch(ch);
356	}
357	if (s & MONSTER) {
358	object *monster;
359
360	if (monster = object_at(&level_monsters, i, j)) {
361	monster->trail_char = ch;
362	}
363	}
364	}
365	}
366	}
367	}
368	}
369
370	dr_course(monster, entering, row, col)
371	object *monster;
372	boolean entering;
373	short row, col;
374	{
375	short i, j, k, rn;
376	short r, rr;
377
378	monster->row = row;
379	monster->col = col;
380
381	if (mon_sees(monster, rogue.row, rogue.col)) {
382	monster->trow = NO_ROOM;
383	return;
384	}
385	rn = get_room_number(row, col);
386
387	if (entering) { /* entering room */
388	/* look for door to some other room */
389	r = get_rand(0, MAXROOMS-1);
390	for (i = 0; i < MAXROOMS; i++) {
391	rr = (r + i) % MAXROOMS;
392	if ((!(rooms[rr].is_room & (R_ROOM \| R_MAZE))) \|\| (rr == rn)) {
393	continue;
394	}
395	for (k = 0; k < 4; k++) {
396	if (rooms[rr].doors[k].oth_room == rn) {
397	monster->trow = rooms[rr].doors[k].oth_row;
398	monster->tcol = rooms[rr].doors[k].oth_col;
399	if ((monster->trow == row) &&
400	(monster->tcol == col)) {
401	continue;
402	}
403	return;
404	}
405	}
406	}
407	/* look for door to dead end */
408	for (i = rooms[rn].top_row; i <= rooms[rn].bottom_row; i++) {
409	for (j = rooms[rn].left_col; j <= rooms[rn].right_col; j++) {
410	if ((i != monster->row) && (j != monster->col) &&
411	(dungeon[i][j] & DOOR)) {
412	monster->trow = i;
413	monster->tcol = j;
414	return;
415	}
416	}
417	}
418	/* return monster to room that he came from */
419	for (i = 0; i < MAXROOMS; i++) {
420	for (j = 0; j < 4; j++) {
421	if (rooms[i].doors[j].oth_room == rn) {
422	for (k = 0; k < 4; k++) {
423	if (rooms[rn].doors[k].oth_room == i) {
424	monster->trow = rooms[rn].doors[k].oth_row;
425	monster->tcol = rooms[rn].doors[k].oth_col;
426	return;
427	}
428	}
429	}
430	}
431	}
432	/* no place to send monster */
433	monster->trow = NO_ROOM;
434	} else { /* exiting room */
435	if (!get_oth_room(rn, &row, &col)) {
436	monster->trow = NO_ROOM;
437	} else {
438	monster->trow = row;
439	monster->tcol = col;
440	}
441	}
442	}
443
444	get_oth_room(rn, row, col)
445	short rn, row, col;
446	{
447	short d = -1;
448
449	if (*row == rooms[rn].top_row) {
450	d = UPWARD/2;
451	} else if (*row == rooms[rn].bottom_row) {
452	d = DOWN/2;
453	} else if (*col == rooms[rn].left_col) {
454	d = LEFT/2;
455	} else if (*col == rooms[rn].right_col) {
456	d = RIGHT/2;
457	}
458	if ((d != -1) && (rooms[rn].doors[d].oth_room >= 0)) {
459	*row = rooms[rn].doors[d].oth_row;
460	*col = rooms[rn].doors[d].oth_col;
461	return(1);
462	}
463	return(0);
464	}
465
466	edit_opts()
467	{
468	char save[NOPTS+1][DCOLS];
469	short i, j;
470	short ch;
471	boolean done = 0;
472	char buf[MAX_OPT_LEN + 2];
473
474	for (i = 0; i < NOPTS+1; i++) {
475	for (j = 0; j < DCOLS; j++) {
476	save[i][j] = mvinch(i, j);
477	}
478	if (i < NOPTS) {
479	opt_show(i);
480	}
481	}
482	opt_go(0);
483	i = 0;
484
485	while (!done) {
486	refresh();
487	ch = rgetchar();
488	CH:
489	switch(ch) {
490	case '\033':
491	done = 1;
492	break;
493	case '\012':
494	case '\015':
495	if (i == (NOPTS - 1)) {
496	mvaddstr(NOPTS, 0, press_space);
497	refresh();
498	wait_for_ack();
499	done = 1;
500	} else {
501	i++;
502	opt_go(i);
503	}
504	break;
505	case '-':
506	if (i > 0) {
507	opt_go(--i);
508	} else {
509	sound_bell();
510	}
511	break;
512	case 't':
513	case 'T':
514	case 'f':
515	case 'F':
516	if (options[i].is_bool) {
517	*(options[i].bval) = (((ch == 't') \|\| (ch == 'T')) ? 1 : 0);
518	opt_show(i);
519	opt_go(++i);
520	break;
521	}
522	default:
523	if (options[i].is_bool) {
524	sound_bell();
525	break;
526	}
527	j = 0;
528	if ((ch == '\010') \|\| ((ch >= ' ') && (ch <= '~'))) {
529	opt_erase(i);
530	do {
531	if ((ch >= ' ') && (ch <= '~') && (j < MAX_OPT_LEN)) {
532	buf[j++] = ch;
533	buf[j] = '\0';
534	addch(ch);
535	} else if ((ch == '\010') && (j > 0)) {
536	buf[--j] = '\0';
537	move(i, j + strlen(options[i].prompt));
538	addch(' ');
539	move(i, j + strlen(options[i].prompt));
540	}
541	refresh();
542	ch = rgetchar();
543	} while ((ch != '\012') && (ch != '\015') && (ch != '\033'));
544	if (j != 0) {
545	(void) strcpy(*(options[i].strval), buf);
546	}
547	opt_show(i);
548	goto CH;
549	} else {
550	sound_bell();
551	}
552	break;
553	}
554	}
555
556	for (i = 0; i < NOPTS+1; i++) {
557	move(i, 0);
558	for (j = 0; j < DCOLS; j++) {
559	addch(save[i][j]);
560	}
561	}
562	}
563
564	opt_show(i)
565	int i;
566	{
567	char *s;
568	struct option *opt = &options[i];
569
570	opt_erase(i);
571
572	if (opt->is_bool) {
573	s = *(opt->bval) ? "True" : "False";
574	} else {
575	s = *(opt->strval);
576	}
577	addstr(s);
578	}
579
580	opt_erase(i)
581	int i;
582	{
583	struct option *opt = &options[i];
584
585	mvaddstr(i, 0, opt->prompt);
586	clrtoeol();
587	}
588
589	opt_go(i)
590	int i;
591	{
592	move(i, strlen(options[i].prompt));
593	}
594
595	do_shell()
596	{
597	#ifdef UNIX
598	char *sh;
599
600	md_ignore_signals();
601	if (!(sh = md_getenv("SHELL"))) {
602	sh = "/bin/sh";
603	}
604	move(LINES-1, 0);
605	refresh();
606	stop_window();
607	printf("\nCreating new shell...\n");
608	md_shell(sh);
609	start_window();
610	wrefresh(curscr);
611	md_heed_signals();
612	#endif
613	}