# 2.11BSD#431 - /usr/src/games/rogue/level.c

##### Functions

    add_exp           X
    add_mazes         X
    check_up          X
    clear_level       X
    connect_rooms     X
    draw_simple_passageX
    drop_check        X
    fill_it           X
    fill_out_level    X
    get_exp_level     X
    hide_boxed_passageX
    hp_raise          X
    make_level        X
    make_maze         X
    make_room         X
    mask_room         X
    mix_random_rooms  X
    put_door          X
    put_player        X
    recursive_deadend X
    same_col          X
    same_row          X
    show_average_hp   X

##### Variables

    cur_level         X
    level_points      X
    max_level         X
    new_level_message X
    party_room        X
    r_de              X
    random_rooms      X

##### Macros

    swap              X

       1: /*
       2:  * level.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[] = "@(#)level.c	5.1 (Berkeley) 11/25/87";
      15: #endif /* not lint */
      16:
      17: #include "rogue.h"
      18:
      19: #define swap(x,y) {t = x; x = y; y = t;}
      20:
      21: short cur_level = 0;
      22: short max_level = 1;
      23: short cur_room;
      24: char *new_level_message = 0;
      25: short party_room = NO_ROOM;
      26: short r_de;
      27:
      28: long level_points[MAX_EXP_LEVEL] = {
      29:           10L,
      30:           20L,
      31:           40L,
      32:           80L,
      33:          160L,
      34:          320L,
      35:          640L,
      36:         1300L,
      37:         2600L,
      38:         5200L,
      39:        10000L,
      40:        20000L,
      41:        40000L,
      42:        80000L,
      43:       160000L,
      44:       320000L,
      45:      1000000L,
      46:      3333333L,
      47:      6666666L,
      48:       MAX_EXP,
      49:     99900000L
      50: };
      51:
      52: short random_rooms[MAXROOMS] = {3, 7, 5, 2, 0, 6, 1, 4, 8};
      53:
      54: extern boolean being_held, wizard, detect_monster;
      55: extern boolean see_invisible;
      56: extern short bear_trap, levitate, extra_hp, less_hp, cur_room;
      57:
      58: make_level()
      59: {
      60:     short i, j;
      61:     short must_1, must_2, must_3;
      62:     boolean big_room;
      63:
      64:     if (cur_level < LAST_DUNGEON) {
      65:         cur_level++;
      66:     }
      67:     if (cur_level > max_level) {
      68:         max_level = cur_level;
      69:     }
      70:     must_1 = get_rand(0, 5);
      71:
      72:     switch(must_1) {
      73:     case 0:
      74:         must_1 = 0;
      75:         must_2 = 1;
      76:         must_3 = 2;
      77:         break;
      78:     case 1:
      79:         must_1 = 3;
      80:         must_2 = 4;
      81:         must_3 = 5;
      82:         break;
      83:     case 2:
      84:         must_1 = 6;
      85:         must_2 = 7;
      86:         must_3 = 8;
      87:         break;
      88:     case 3:
      89:         must_1 = 0;
      90:         must_2 = 3;
      91:         must_3 = 6;
      92:         break;
      93:     case 4:
      94:         must_1 = 1;
      95:         must_2 = 4;
      96:         must_3 = 7;
      97:         break;
      98:     case 5:
      99:         must_1 = 2;
     100:         must_2 = 5;
     101:         must_3 = 8;
     102:         break;
     103:     }
     104:     if (rand_percent(8)) {
     105:         party_room = 0;
     106:     }
     107:     big_room = ((party_room != NO_ROOM) && rand_percent(1));
     108:     if (big_room) {
     109:         make_room(BIG_ROOM, 0, 0, 0);
     110:     } else {
     111:         for (i = 0; i < MAXROOMS; i++) {
     112:             make_room(i, must_1, must_2, must_3);
     113:         }
     114:     }
     115:     if (!big_room) {
     116:         add_mazes();
     117:
     118:         mix_random_rooms();
     119:
     120:         for (j = 0; j < MAXROOMS; j++) {
     121:
     122:             i = random_rooms[j];
     123:
     124:             if (i < (MAXROOMS-1)) {
     125:                 (void) connect_rooms(i, i+1);
     126:             }
     127:             if (i < (MAXROOMS-3)) {
     128:                 (void) connect_rooms(i, i+3);
     129:             }
     130:             if (i < (MAXROOMS-2)) {
     131:                 if (rooms[i+1].is_room & R_NOTHING) {
     132:                     if (connect_rooms(i, i+2)) {
     133:                         rooms[i+1].is_room = R_CROSS;
     134:                     }
     135:                 }
     136:             }
     137:             if (i < (MAXROOMS-6)) {
     138:                 if (rooms[i+3].is_room & R_NOTHING) {
     139:                     if (connect_rooms(i, i+6)) {
     140:                         rooms[i+3].is_room = R_CROSS;
     141:                     }
     142:                 }
     143:             }
     144:             if (is_all_connected()) {
     145:                 break;
     146:             }
     147:         }
     148:         fill_out_level();
     149:     }
     150:     if (!has_amulet() && (cur_level >= AMULET_LEVEL)) {
     151:         put_amulet();
     152:     }
     153: }
     154:
     155: make_room(rn, r1, r2, r3)
     156: short rn, r1, r2, r3;
     157: {
     158:     short left_col, right_col, top_row, bottom_row;
     159:     short width, height;
     160:     short row_offset, col_offset;
     161:     short i, j, ch;
     162:
     163:     switch(rn) {
     164:     case 0:
     165:         left_col = 0;
     166:         right_col = COL1-1;
     167:         top_row = MIN_ROW;
     168:         bottom_row = ROW1-1;
     169:         break;
     170:     case 1:
     171:         left_col = COL1+1;
     172:         right_col = COL2-1;
     173:         top_row = MIN_ROW;
     174:         bottom_row = ROW1-1;
     175:         break;
     176:     case 2:
     177:         left_col = COL2+1;
     178:         right_col = DCOLS-1;
     179:         top_row = MIN_ROW;
     180:         bottom_row = ROW1-1;
     181:         break;
     182:     case 3:
     183:         left_col = 0;
     184:         right_col = COL1-1;
     185:         top_row = ROW1+1;
     186:         bottom_row = ROW2-1;
     187:         break;
     188:     case 4:
     189:         left_col = COL1+1;
     190:         right_col = COL2-1;
     191:         top_row = ROW1+1;
     192:         bottom_row = ROW2-1;
     193:         break;
     194:     case 5:
     195:         left_col = COL2+1;
     196:         right_col = DCOLS-1;
     197:         top_row = ROW1+1;
     198:         bottom_row = ROW2-1;
     199:         break;
     200:     case 6:
     201:         left_col = 0;
     202:         right_col = COL1-1;
     203:         top_row = ROW2+1;
     204:         bottom_row = DROWS - 2;
     205:         break;
     206:     case 7:
     207:         left_col = COL1+1;
     208:         right_col = COL2-1;
     209:         top_row = ROW2+1;
     210:         bottom_row = DROWS - 2;
     211:         break;
     212:     case 8:
     213:         left_col = COL2+1;
     214:         right_col = DCOLS-1;
     215:         top_row = ROW2+1;
     216:         bottom_row = DROWS - 2;
     217:         break;
     218:     case BIG_ROOM:
     219:         top_row = get_rand(MIN_ROW, MIN_ROW+5);
     220:         bottom_row = get_rand(DROWS-7, DROWS-2);
     221:         left_col = get_rand(0, 10);;
     222:         right_col = get_rand(DCOLS-11, DCOLS-1);
     223:         rn = 0;
     224:         goto B;
     225:     }
     226:     height = get_rand(4, (bottom_row - top_row + 1));
     227:     width = get_rand(7, (right_col - left_col - 2));
     228:
     229:     row_offset = get_rand(0, ((bottom_row - top_row) - height + 1));
     230:     col_offset = get_rand(0, ((right_col - left_col) - width + 1));
     231:
     232:     top_row += row_offset;
     233:     bottom_row = top_row + height - 1;
     234:
     235:     left_col += col_offset;
     236:     right_col = left_col + width - 1;
     237:
     238:     if ((rn != r1) && (rn != r2) && (rn != r3) && rand_percent(40)) {
     239:         goto END;
     240:     }
     241: B:
     242:     rooms[rn].is_room = R_ROOM;
     243:
     244:     for (i = top_row; i <= bottom_row; i++) {
     245:         for (j = left_col; j <= right_col; j++) {
     246:             if ((i == top_row) || (i == bottom_row)) {
     247:                 ch = HORWALL;
     248:             } else if ( ((i != top_row) && (i != bottom_row)) &&
     249:                         ((j == left_col) || (j == right_col))) {
     250:                 ch = VERTWALL;
     251:             } else {
     252:                 ch = FLOOR;
     253:             }
     254:             dungeon[i][j] = ch;
     255:         }
     256:     }
     257: END:
     258:     rooms[rn].top_row = top_row;
     259:     rooms[rn].bottom_row = bottom_row;
     260:     rooms[rn].left_col = left_col;
     261:     rooms[rn].right_col = right_col;
     262: }
     263:
     264: connect_rooms(room1, room2)
     265: short room1, room2;
     266: {
     267:     short row1, col1, row2, col2, dir;
     268:
     269:     if ((!(rooms[room1].is_room & (R_ROOM | R_MAZE))) ||
     270:         (!(rooms[room2].is_room & (R_ROOM | R_MAZE)))) {
     271:         return(0);
     272:     }
     273:     if (same_row(room1, room2) &&
     274:         (rooms[room1].left_col > rooms[room2].right_col)) {
     275:         put_door(&rooms[room1], LEFT, &row1, &col1);
     276:         put_door(&rooms[room2], RIGHT, &row2, &col2);
     277:         dir = LEFT;
     278:     } else if (same_row(room1, room2) &&
     279:         (rooms[room2].left_col > rooms[room1].right_col)) {
     280:         put_door(&rooms[room1], RIGHT, &row1, &col1);
     281:         put_door(&rooms[room2], LEFT, &row2, &col2);
     282:         dir = RIGHT;
     283:     } else if (same_col(room1, room2) &&
     284:         (rooms[room1].top_row > rooms[room2].bottom_row)) {
     285:         put_door(&rooms[room1], UPWARD, &row1, &col1);
     286:         put_door(&rooms[room2], DOWN, &row2, &col2);
     287:         dir = UPWARD;
     288:     } else if (same_col(room1, room2) &&
     289:         (rooms[room2].top_row > rooms[room1].bottom_row)) {
     290:         put_door(&rooms[room1], DOWN, &row1, &col1);
     291:         put_door(&rooms[room2], UPWARD, &row2, &col2);
     292:         dir = DOWN;
     293:     } else {
     294:         return(0);
     295:     }
     296:
     297:     do {
     298:         draw_simple_passage(row1, col1, row2, col2, dir);
     299:     } while (rand_percent(4));
     300:
     301:     rooms[room1].doors[dir/2].oth_room = room2;
     302:     rooms[room1].doors[dir/2].oth_row = row2;
     303:     rooms[room1].doors[dir/2].oth_col = col2;
     304:
     305:     rooms[room2].doors[(((dir+4)%DIRS)/2)].oth_room = room1;
     306:     rooms[room2].doors[(((dir+4)%DIRS)/2)].oth_row = row1;
     307:     rooms[room2].doors[(((dir+4)%DIRS)/2)].oth_col = col1;
     308:     return(1);
     309: }
     310:
     311: clear_level()
     312: {
     313:     short i, j;
     314:
     315:     for (i = 0; i < MAXROOMS; i++) {
     316:         rooms[i].is_room = R_NOTHING;
     317:         for (j = 0; j < 4; j++) {
     318:             rooms[i].doors[j].oth_room = NO_ROOM;
     319:         }
     320:     }
     321:
     322:     for (i = 0; i < MAX_TRAPS; i++) {
     323:         traps[i].trap_type = NO_TRAP;
     324:     }
     325:     for (i = 0; i < DROWS; i++) {
     326:         for (j = 0; j < DCOLS; j++) {
     327:             dungeon[i][j] = NOTHING;
     328:         }
     329:     }
     330:     detect_monster = see_invisible = 0;
     331:     being_held = bear_trap = 0;
     332:     party_room = NO_ROOM;
     333:     rogue.row = rogue.col = -1;
     334:     clear();
     335: }
     336:
     337: put_door(rm, dir, row, col)
     338: room *rm;
     339: short dir;
     340: short *row, *col;
     341: {
     342:     short wall_width;
     343:
     344:     wall_width = (rm->is_room & R_MAZE) ? 0 : 1;
     345:
     346:     switch(dir) {
     347:     case UPWARD:
     348:     case DOWN:
     349:         *row = ((dir == UPWARD) ? rm->top_row : rm->bottom_row);
     350:         do {
     351:             *col = get_rand(rm->left_col+wall_width,
     352:                 rm->right_col-wall_width);
     353:         } while (!(dungeon[*row][*col] & (HORWALL | TUNNEL)));
     354:         break;
     355:     case RIGHT:
     356:     case LEFT:
     357:         *col = (dir == LEFT) ? rm->left_col : rm->right_col;
     358:         do {
     359:             *row = get_rand(rm->top_row+wall_width,
     360:                 rm->bottom_row-wall_width);
     361:         } while (!(dungeon[*row][*col] & (VERTWALL | TUNNEL)));
     362:         break;
     363:     }
     364:     if (rm->is_room & R_ROOM) {
     365:         dungeon[*row][*col] = DOOR;
     366:     }
     367:     if ((cur_level > 2) && rand_percent(HIDE_PERCENT)) {
     368:         dungeon[*row][*col] |= HIDDEN;
     369:     }
     370:     rm->doors[dir/2].door_row = *row;
     371:     rm->doors[dir/2].door_col = *col;
     372: }
     373:
     374: draw_simple_passage(row1, col1, row2, col2, dir)
     375: short row1, col1, row2, col2, dir;
     376: {
     377:     short i, middle, t;
     378:
     379:     if ((dir == LEFT) || (dir == RIGHT)) {
     380:         if (col1 > col2) {
     381:             swap(row1, row2);
     382:             swap(col1, col2);
     383:         }
     384:         middle = get_rand(col1+1, col2-1);
     385:         for (i = col1+1; i != middle; i++) {
     386:             dungeon[row1][i] = TUNNEL;
     387:         }
     388:         for (i = row1; i != row2; i += (row1 > row2) ? -1 : 1) {
     389:             dungeon[i][middle] = TUNNEL;
     390:         }
     391:         for (i = middle; i != col2; i++) {
     392:             dungeon[row2][i] = TUNNEL;
     393:         }
     394:     } else {
     395:         if (row1 > row2) {
     396:             swap(row1, row2);
     397:             swap(col1, col2);
     398:         }
     399:         middle = get_rand(row1+1, row2-1);
     400:         for (i = row1+1; i != middle; i++) {
     401:             dungeon[i][col1] = TUNNEL;
     402:         }
     403:         for (i = col1; i != col2; i += (col1 > col2) ? -1 : 1) {
     404:             dungeon[middle][i] = TUNNEL;
     405:         }
     406:         for (i = middle; i != row2; i++) {
     407:             dungeon[i][col2] = TUNNEL;
     408:         }
     409:     }
     410:     if (rand_percent(HIDE_PERCENT)) {
     411:         hide_boxed_passage(row1, col1, row2, col2, 1);
     412:     }
     413: }
     414:
     415: same_row(room1, room2)
     416: {
     417:     return((room1 / 3) == (room2 / 3));
     418: }
     419:
     420: same_col(room1, room2)
     421: {
     422:     return((room1 % 3) == (room2 % 3));
     423: }
     424:
     425: add_mazes()
     426: {
     427:     short i, j;
     428:     short start;
     429:     short maze_percent;
     430:
     431:     if (cur_level > 1) {
     432:         start = get_rand(0, (MAXROOMS-1));
     433:         maze_percent = (cur_level * 5) / 4;
     434:
     435:         if (cur_level > 15) {
     436:             maze_percent += cur_level;
     437:         }
     438:         for (i = 0; i < MAXROOMS; i++) {
     439:             j = ((start + i) % MAXROOMS);
     440:             if (rooms[j].is_room & R_NOTHING) {
     441:                 if (rand_percent(maze_percent)) {
     442:                 rooms[j].is_room = R_MAZE;
     443:                 make_maze(get_rand(rooms[j].top_row+1, rooms[j].bottom_row-1),
     444:                     get_rand(rooms[j].left_col+1, rooms[j].right_col-1),
     445:                     rooms[j].top_row, rooms[j].bottom_row,
     446:                     rooms[j].left_col, rooms[j].right_col);
     447:                 hide_boxed_passage(rooms[j].top_row, rooms[j].left_col,
     448:                     rooms[j].bottom_row, rooms[j].right_col,
     449:                     get_rand(0, 2));
     450:                 }
     451:             }
     452:         }
     453:     }
     454: }
     455:
     456: fill_out_level()
     457: {
     458:     short i, rn;
     459:
     460:     mix_random_rooms();
     461:
     462:     r_de = NO_ROOM;
     463:
     464:     for (i = 0; i < MAXROOMS; i++) {
     465:         rn = random_rooms[i];
     466:         if ((rooms[rn].is_room & R_NOTHING) ||
     467:             ((rooms[rn].is_room & R_CROSS) && coin_toss())) {
     468:             fill_it(rn, 1);
     469:         }
     470:     }
     471:     if (r_de != NO_ROOM) {
     472:         fill_it(r_de, 0);
     473:     }
     474: }
     475:
     476: fill_it(rn, do_rec_de)
     477: int rn;
     478: boolean do_rec_de;
     479: {
     480:     short i, tunnel_dir, door_dir, drow, dcol;
     481:     short target_room, rooms_found = 0;
     482:     short srow, scol, t;
     483:     static short offsets[4] = {-1, 1, 3, -3};
     484:     boolean did_this = 0;
     485:
     486:     for (i = 0; i < 10; i++) {
     487:         srow = get_rand(0, 3);
     488:         scol = get_rand(0, 3);
     489:         t = offsets[srow];
     490:         offsets[srow] = offsets[scol];
     491:         offsets[scol] = t;
     492:     }
     493:     for (i = 0; i < 4; i++) {
     494:
     495:         target_room = rn + offsets[i];
     496:
     497:         if (((target_room < 0) || (target_room >= MAXROOMS)) ||
     498:             (!(same_row(rn,target_room) || same_col(rn,target_room))) ||
     499:             (!(rooms[target_room].is_room & (R_ROOM | R_MAZE)))) {
     500:             continue;
     501:         }
     502:         if (same_row(rn, target_room)) {
     503:             tunnel_dir = (rooms[rn].left_col < rooms[target_room].left_col) ?
     504:                 RIGHT : LEFT;
     505:         } else {
     506:             tunnel_dir = (rooms[rn].top_row < rooms[target_room].top_row) ?
     507:                 DOWN : UPWARD;
     508:         }
     509:         door_dir = ((tunnel_dir + 4) % DIRS);
     510:         if (rooms[target_room].doors[door_dir/2].oth_room != NO_ROOM) {
     511:             continue;
     512:         }
     513:         if (((!do_rec_de) || did_this) ||
     514:             (!mask_room(rn, &srow, &scol, TUNNEL))) {
     515:             srow = (rooms[rn].top_row + rooms[rn].bottom_row) / 2;
     516:             scol = (rooms[rn].left_col + rooms[rn].right_col) / 2;
     517:         }
     518:         put_door(&rooms[target_room], door_dir, &drow, &dcol);
     519:         rooms_found++;
     520:         draw_simple_passage(srow, scol, drow, dcol, tunnel_dir);
     521:         rooms[rn].is_room = R_DEADEND;
     522:         dungeon[srow][scol] = TUNNEL;
     523:
     524:         if ((i < 3) && (!did_this)) {
     525:             did_this = 1;
     526:             if (coin_toss()) {
     527:                 continue;
     528:             }
     529:         }
     530:         if ((rooms_found < 2) && do_rec_de) {
     531:             recursive_deadend(rn, offsets, srow, scol);
     532:         }
     533:         break;
     534:     }
     535: }
     536:
     537: recursive_deadend(rn, offsets, srow, scol)
     538: short rn;
     539: short *offsets;
     540: short srow, scol;
     541: {
     542:     short i, de;
     543:     short drow, dcol, tunnel_dir;
     544:
     545:     rooms[rn].is_room = R_DEADEND;
     546:     dungeon[srow][scol] = TUNNEL;
     547:
     548:     for (i = 0; i < 4; i++) {
     549:         de = rn + offsets[i];
     550:         if (((de < 0) || (de >= MAXROOMS)) ||
     551:             (!(same_row(rn, de) || same_col(rn, de)))) {
     552:             continue;
     553:         }
     554:         if (!(rooms[de].is_room & R_NOTHING)) {
     555:             continue;
     556:         }
     557:         drow = (rooms[de].top_row + rooms[de].bottom_row) / 2;
     558:         dcol = (rooms[de].left_col + rooms[de].right_col) / 2;
     559:         if (same_row(rn, de)) {
     560:             tunnel_dir = (rooms[rn].left_col < rooms[de].left_col) ?
     561:                 RIGHT : LEFT;
     562:         } else {
     563:             tunnel_dir = (rooms[rn].top_row < rooms[de].top_row) ?
     564:                 DOWN : UPWARD;
     565:         }
     566:         draw_simple_passage(srow, scol, drow, dcol, tunnel_dir);
     567:         r_de = de;
     568:         recursive_deadend(de, offsets, drow, dcol);
     569:     }
     570: }
     571:
     572: boolean
     573: mask_room(rn, row, col, mask)
     574: short rn;
     575: short *row, *col;
     576: unsigned short mask;
     577: {
     578:     short i, j;
     579:
     580:     for (i = rooms[rn].top_row; i <= rooms[rn].bottom_row; i++) {
     581:         for (j = rooms[rn].left_col; j <= rooms[rn].right_col; j++) {
     582:             if (dungeon[i][j] & mask) {
     583:                 *row = i;
     584:                 *col = j;
     585:                 return(1);
     586:             }
     587:         }
     588:     }
     589:     return(0);
     590: }
     591:
     592: make_maze(r, c, tr, br, lc, rc)
     593: short r, c, tr, br, lc, rc;
     594: {
     595:     char dirs[4];
     596:     short i, t;
     597:
     598:     dirs[0] = UPWARD;
     599:     dirs[1] = DOWN;
     600:     dirs[2] = LEFT;
     601:     dirs[3] = RIGHT;
     602:
     603:     dungeon[r][c] = TUNNEL;
     604:
     605:     if (rand_percent(20)) {
     606:         for (i = 0; i < 10; i++) {
     607:             short t1, t2;
     608:
     609:             t1 = get_rand(0, 3);
     610:             t2 = get_rand(0, 3);
     611:
     612:             swap(dirs[t1], dirs[t2]);
     613:         }
     614:     }
     615:     for (i = 0; i < 4; i++) {
     616:         switch(dirs[i]) {
     617:         case UPWARD:
     618:             if (((r-1) >= tr) &&
     619:                 (dungeon[r-1][c] != TUNNEL) &&
     620:                 (dungeon[r-1][c-1] != TUNNEL) &&
     621:                 (dungeon[r-1][c+1] != TUNNEL) &&
     622:                 (dungeon[r-2][c] != TUNNEL)) {
     623:                 make_maze((r-1), c, tr, br, lc, rc);
     624:             }
     625:             break;
     626:         case DOWN:
     627:             if (((r+1) <= br) &&
     628:                 (dungeon[r+1][c] != TUNNEL) &&
     629:                 (dungeon[r+1][c-1] != TUNNEL) &&
     630:                 (dungeon[r+1][c+1] != TUNNEL) &&
     631:                 (dungeon[r+2][c] != TUNNEL)) {
     632:                 make_maze((r+1), c, tr, br, lc, rc);
     633:             }
     634:             break;
     635:         case LEFT:
     636:             if (((c-1) >= lc) &&
     637:                 (dungeon[r][c-1] != TUNNEL) &&
     638:                 (dungeon[r-1][c-1] != TUNNEL) &&
     639:                 (dungeon[r+1][c-1] != TUNNEL) &&
     640:                 (dungeon[r][c-2] != TUNNEL)) {
     641:                 make_maze(r, (c-1), tr, br, lc, rc);
     642:             }
     643:             break;
     644:         case RIGHT:
     645:             if (((c+1) <= rc) &&
     646:                 (dungeon[r][c+1] != TUNNEL) &&
     647:                 (dungeon[r-1][c+1] != TUNNEL) &&
     648:                 (dungeon[r+1][c+1] != TUNNEL) &&
     649:                 (dungeon[r][c+2] != TUNNEL)) {
     650:                 make_maze(r, (c+1), tr, br, lc, rc);
     651:             }
     652:             break;
     653:         }
     654:     }
     655: }
     656:
     657: hide_boxed_passage(row1, col1, row2, col2, n)
     658: short row1, col1, row2, col2, n;
     659: {
     660:     short i, j, t;
     661:     short row, col, row_cut, col_cut;
     662:     short h, w;
     663:
     664:     if (cur_level > 2) {
     665:         if (row1 > row2) {
     666:             swap(row1, row2);
     667:         }
     668:         if (col1 > col2) {
     669:             swap(col1, col2);
     670:         }
     671:         h = row2 - row1;
     672:         w = col2 - col1;
     673:
     674:         if ((w >= 5) || (h >= 5)) {
     675:             row_cut = ((h >= 2) ? 1 : 0);
     676:             col_cut = ((w >= 2) ? 1 : 0);
     677:
     678:             for (i = 0; i < n; i++) {
     679:                 for (j = 0; j < 10; j++) {
     680:                     row = get_rand(row1 + row_cut, row2 - row_cut);
     681:                     col = get_rand(col1 + col_cut, col2 - col_cut);
     682:                     if (dungeon[row][col] == TUNNEL) {
     683:                         dungeon[row][col] |= HIDDEN;
     684:                         break;
     685:                     }
     686:                 }
     687:             }
     688:         }
     689:     }
     690: }
     691:
     692: put_player(nr)
     693: short nr;       /* try not to put in this room */
     694: {
     695:     short rn = nr, misses;
     696:     short row, col;
     697:
     698:     for (misses = 0; ((misses < 2) && (rn == nr)); misses++) {
     699:         gr_row_col(&row, &col, (FLOOR | TUNNEL | OBJECT | STAIRS));
     700:         rn = get_room_number(row, col);
     701:     }
     702:     rogue.row = row;
     703:     rogue.col = col;
     704:
     705:     if (dungeon[rogue.row][rogue.col] & TUNNEL) {
     706:         cur_room = PASSAGE;
     707:     } else {
     708:         cur_room = rn;
     709:     }
     710:     if (cur_room != PASSAGE) {
     711:         light_up_room(cur_room);
     712:     } else {
     713:         light_passage(rogue.row, rogue.col);
     714:     }
     715:     rn = get_room_number(rogue.row, rogue.col);
     716:     wake_room(rn, 1, rogue.row, rogue.col);
     717:     if (new_level_message) {
     718:         message(new_level_message, 0);
     719:         new_level_message = 0;
     720:     }
     721:     mvaddch(rogue.row, rogue.col, rogue.fchar);
     722: }
     723:
     724: drop_check()
     725: {
     726:     if (wizard) {
     727:         return(1);
     728:     }
     729:     if (dungeon[rogue.row][rogue.col] & STAIRS) {
     730:         if (levitate) {
     731:             message("you're floating in the air!", 0);
     732:             return(0);
     733:         }
     734:         return(1);
     735:     }
     736:     message("I see no way down", 0);
     737:     return(0);
     738: }
     739:
     740: check_up()
     741: {
     742:     if (!wizard) {
     743:         if (!(dungeon[rogue.row][rogue.col] & STAIRS)) {
     744:             message("I see no way up", 0);
     745:             return(0);
     746:         }
     747:         if (!has_amulet()) {
     748:             message("your way is magically blocked", 0);
     749:             return(0);
     750:         }
     751:     }
     752:     new_level_message = "you feel a wrenching sensation in your gut";
     753:     if (cur_level == 1) {
     754:         win();
     755:     } else {
     756:         cur_level -= 2;
     757:         return(1);
     758:     }
     759:     return(0);
     760: }
     761:
     762: add_exp(e, promotion)
     763: int e;
     764: boolean promotion;
     765: {
     766:     char mbuf[40];
     767:     short new_exp;
     768:     short i, hp;
     769:
     770:     rogue.exp_points += e;
     771:
     772:     if (rogue.exp_points >= level_points[rogue.exp-1]) {
     773:         new_exp = get_exp_level(rogue.exp_points);
     774:         if (rogue.exp_points > MAX_EXP) {
     775:             rogue.exp_points = MAX_EXP + 1;
     776:         }
     777:         for (i = rogue.exp+1; i <= new_exp; i++) {
     778:             sprintf(mbuf, "welcome to level %d", i);
     779:             message(mbuf, 0);
     780:             if (promotion) {
     781:                 hp = hp_raise();
     782:                 rogue.hp_current += hp;
     783:                 rogue.hp_max += hp;
     784:             }
     785:             rogue.exp = i;
     786:             print_stats(STAT_HP | STAT_EXP);
     787:         }
     788:     } else {
     789:         print_stats(STAT_EXP);
     790:     }
     791: }
     792:
     793: get_exp_level(e)
     794: long e;
     795: {
     796:     short i;
     797:
     798:     for (i = 0; i < (MAX_EXP_LEVEL - 1); i++) {
     799:         if (level_points[i] > e) {
     800:             break;
     801:         }
     802:     }
     803:     return(i+1);
     804: }
     805:
     806: hp_raise()
     807: {
     808:     int hp;
     809:
     810:     hp = (wizard ? 10 : get_rand(3, 10));
     811:     return(hp);
     812: }
     813:
     814: show_average_hp()
     815: {
     816:     char mbuf[80];
     817:     float real_average;
     818:     float effective_average;
     819:
     820:     if (rogue.exp == 1) {
     821:         real_average = effective_average = 0.00;
     822:     } else {
     823:         real_average = (float)
     824:             ((rogue.hp_max - extra_hp - INIT_HP) + less_hp) / (rogue.exp - 1);
     825:         effective_average = (float) (rogue.hp_max - INIT_HP) / (rogue.exp - 1);
     826:
     827:     }
     828:     sprintf(mbuf, "R-Hp: %.2f, E-Hp: %.2f (!: %d, V: %d)", real_average,
     829:         effective_average, extra_hp, less_hp);
     830:     message(mbuf, 0);
     831: }
     832:
     833: mix_random_rooms()
     834: {
     835:     short i, t;
     836:     short x, y;
     837:
     838:     for (i = 0; i < (3 * MAXROOMS); i++) {
     839:         do {
     840:             x = get_rand(0, (MAXROOMS-1));
     841:             y = get_rand(0, (MAXROOMS-1));
     842:         } while (x == y);
     843:         swap(random_rooms[x], random_rooms[y]);
     844:     }
     845: }

#### Defined functions

add_exp defined in line 762; used 4 times

- in /usr/src/games/rogue/hit.c line 273
- in /usr/src/games/rogue/spec_hit.c line 390
- in /usr/src/games/rogue/use.c line 93, 389

add_mazes defined in line 425; used 1 times

- in line 116

check_up defined in line 740; used 1 times

- in /usr/src/games/rogue/play.c line 133

clear_level defined in line 311; used 1 times

- in /usr/src/games/rogue/main.c line 30

connect_rooms defined in line 264; used 4 times

- in line 125-132(3), 139

draw_simple_passage defined in line 374; used 3 times

- in line 298, 520, 566

drop_check defined in line 724; used 1 times

- in /usr/src/games/rogue/play.c line 128

fill_it defined in line 476; used 2 times

- in line 468-472(2)

fill_out_level defined in line 456; used 1 times

- in line 148

get_exp_level defined in line 793; used 1 times

- in line 773

hide_boxed_passage defined in line 657; used 2 times

- in line 411, 447

hp_raise defined in line 806; used 2 times

- in line 781
- in /usr/src/games/rogue/spec_hit.c line 383

make_level defined in line 58; used 1 times

- in /usr/src/games/rogue/main.c line 31

make_maze defined in line 592; used 5 times

- in line 443, 623, 632, 641, 650

make_room defined in line 155; used 2 times

- in line 109-112(2)

mask_room defined in line 572; used 2 times

- in line 514
- in /usr/src/games/rogue/rogue.h line 409

mix_random_rooms defined in line 833; used 2 times

- in line 118, 460

put_door defined in line 337; used 9 times

- in line 275-291(8), 518

put_player defined in line 692; used 2 times

- in /usr/src/games/rogue/main.c line 36
- in /usr/src/games/rogue/use.c line 438

recursive_deadend defined in line 537; used 2 times

- in line 531, 568

same_col defined in line 420; used 4 times

- in line 283-288(2), 498, 551

same_row defined in line 415; used 6 times

- in line 273-278(2), 498-502(2), 551, 559

show_average_hp defined in line 814; used 1 times

- in /usr/src/games/rogue/play.c line 238

#### Defined variables

cur_level defined in line 21; used 42 times

- in line 64-68(4), 150, 367, 431-436(4), 664, 753-756(2)
- in /usr/src/games/rogue/hit.c line 37, 66-67(2)
- in /usr/src/games/rogue/message.c line 198
- in /usr/src/games/rogue/monster.c line 119-120(2), 129, 192, 217
- in /usr/src/games/rogue/move.c line 410
- in /usr/src/games/rogue/object.c line 130, 185(2), 312
- in /usr/src/games/rogue/save.c line 84(2), 146(2)
- in /usr/src/games/rogue/spec_hit.c line 120(2), 208, 215(2)
- in /usr/src/games/rogue/trap.c line 115-125(6)

cur_room declared in line 56; defined in line 23; used 29 times

- in line 706-711(4)
- in /usr/src/games/rogue/monster.c line 441, 691-692(2)
- in /usr/src/games/rogue/move.c line 73-76(4), 83-85(3)
- in /usr/src/games/rogue/save.c line 102(2), 173(2)
- in /usr/src/games/rogue/use.c line 435-436(2), 494-497(2), 535-539(5)
- in /usr/src/games/rogue/zap.c line 218-222(2)

level_points defined in line 28; used 4 times

- in line 772, 799
- in /usr/src/games/rogue/spec_hit.c line 381
- in /usr/src/games/rogue/use.c line 91

max_level defined in line 22; used 10 times

- in line 67-68(2)
- in /usr/src/games/rogue/move.c line 410
- in /usr/src/games/rogue/object.c line 130
- in /usr/src/games/rogue/save.c line 85(2), 147(2)
- in /usr/src/games/rogue/score.c line 333
- in /usr/src/games/rogue/spec_hit.c line 208

new_level_message defined in line 24; used 5 times

- in line 717-719(3), 752
- in /usr/src/games/rogue/trap.c line 74

party_room defined in line 25; used 18 times

- in line 105-107(2), 332
- in /usr/src/games/rogue/main.c line 36
- in /usr/src/games/rogue/monster.c line 512
- in /usr/src/games/rogue/object.c line 137, 609-613(3)
- in /usr/src/games/rogue/save.c line 88(2), 156(2)
- in /usr/src/games/rogue/trap.c line 133-138(5)

r_de defined in line 26; used 4 times

- in line 462, 471-472(2), 567

random_rooms defined in line 52; used 4 times

- in line 122, 465, 843(2)

sccsid defined in line 14; never used

#### Defined macros

swap defined in line 19; used 8 times

- in line 381-382(2), 396-397(2), 612, 666-669(2), 843

Last modified: 1987-11-26 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 2641 |