Return to room.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / games / rogue

Annotation of 43BSDTahoe/games/rogue/room.c, revision 1.1

1.1     ! root        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) 11/25/87";
        !            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: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.