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