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